home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / public / fax / src / etc / faxaddmodem.sh < prev    next >
Linux/UNIX/POSIX Shell Script  |  1994-08-01  |  81KB  |  2,559 lines
  1. #! /bin/sh
  2. #    $Header: /usr/people/sam/fax/etc/RCS/faxaddmodem.sh,v 1.104 1994/04/25 17:05:34 sam Rel $
  3. #
  4. # FlexFAX Facsimile Software
  5. #
  6. # Copyright (c) 1990, 1991, 1992, 1993, 1994 Sam Leffler
  7. # Copyright (c) 1991, 1992, 1993, 1994 Silicon Graphics, Inc.
  8. # 
  9. # Permission to use, copy, modify, distribute, and sell this software and 
  10. # its documentation for any purpose is hereby granted without fee, provided
  11. # that (i) the above copyright notices and this permission notice appear in
  12. # all copies of the software and related documentation, and (ii) the names of
  13. # Sam Leffler and Silicon Graphics may not be used in any advertising or
  14. # publicity relating to the software without the specific, prior written
  15. # permission of Sam Leffler and Silicon Graphics.
  16. # 
  17. # THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 
  18. # EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 
  19. # WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  
  20. # 
  21. # IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
  22. # ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
  23. # OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  24. # WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF 
  25. # LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 
  26. # OF THIS SOFTWARE.
  27. #
  28.  
  29. #
  30. # faxaddmodem [tty]
  31. #
  32. # This script interactively configures a FlexFAX server
  33. # from keyboard input on a standard terminal.  There may
  34. # be some system dependencies in here; hard to say with
  35. # this mountain of shell code!
  36. #
  37. PATH=/bin:/usr/bin:/etc
  38. test -d /usr/ucb  && PATH=$PATH:/usr/ucb        # Sun and others
  39. test -d /usr/bsd  && PATH=$PATH:/usr/bsd        # Silicon Graphics
  40. test -d /usr/5bin && PATH=/usr/5bin:$PATH:/usr/etc    # Sun and others
  41. test -d /usr/sbin && PATH=/usr/sbin:$PATH        # 4.4BSD-derived
  42.  
  43. OS=`uname -s 2>/dev/null || echo unknown`        # system identification
  44. case "$OS" in
  45. # believable values...
  46. IRIX|*BSD*|*bsd*|SunOS|Linux|ULTRIX|HP-UX) ;;
  47. *)  if [ -d /etc/saf ]; then
  48.     # uname -s is unreliable on svr4 as it can return the nodename
  49.     OS=svr4
  50.     fi
  51.     ;;
  52. esac
  53. SPEEDS="76800 57600 38400 19200 9600 4800 2400 1200"    # set of speeds to try
  54. SPEED=
  55.  
  56. while [ x"$1" != x"" ] ; do
  57.     case $1 in
  58.     -os)    OS=$2; shift;;
  59.     -s)        SPEED=$2; shift;;
  60.     -*)        echo "Usage: $0 [-os OS] [-s SPEED] [ttyname]"; exit 1;;
  61.     *)        TTY=$1;;
  62.     esac
  63.     shift
  64. done
  65.  
  66. #
  67. # Deduce the effective user id:
  68. #   1. POSIX-style, the id program
  69. #   2. the old whoami program
  70. #   3. last gasp, check if we have write permission on /dev
  71. #
  72. euid=`id|sed -e 's/.*uid=[0-9]*(\([^)]*\)).*/\1/'`
  73. test -z "$euid" && euid=`whoami 2>/dev/null`
  74. test -z "$euid" -a -w /dev && euid=root
  75. if [ "$euid" != "root" ]; then
  76.     echo "Sorry, but you must run this script as the super-user!"
  77.     exit 1
  78. fi
  79.  
  80. SPOOL=/usr/spool/fax        # top of fax spooling tree
  81. CPATH=$SPOOL/etc/config        # prefix of configuration file
  82. LOCKDIR=/usr/spool/locks    # UUCP locking directory
  83. OUT=/tmp/addmodem$$        # temp file in which modem output is recorded
  84. SVR4UULCKN=$SPOOL/bin/lockname    # SVR4 UUCP lock name construction program
  85. ONDELAY=$SPOOL/bin/ondelay    # prgm to open devices blocking on carrier
  86. CAT="cat -u"            # something to do unbuffered reads and writes
  87. FAX=fax                # identity of the fax user
  88. SERVICES=/etc/services        # location of services database
  89. INETDCONF=/usr/etc/inetd.conf    # default location of inetd configuration file
  90. ALIASES=/usr/lib/aliases    # default location of mail aliases database file
  91. SGIPASSWD=/etc/passwd.sgi    # for hiding fax user from pandor on SGI's
  92. PASSWD=/etc/passwd        # where to go for password entries
  93. PROTOUID=uucp            # user who's uid we use for FAX user
  94. defPROTOUID=3            # use this uid if PROTOUID doesn't exist
  95. GROUP=/etc/group        # where to go for group entries
  96. PROTOGID=nuucp            # group who's gid we use for FAX user
  97. defPROTOGID=10            # use this gid if PROTOGID doesn't exist
  98. SERVERDIR=/usr/etc        # directory where servers are located
  99. QUIT=/usr/local/bin/faxquit    # cmd to terminate server
  100. MODEMCONFIG=$SPOOL/etc        # location of prototype modem config files
  101.  
  102. #
  103. # Deal with known alternate locations for system files.
  104. #
  105. PickFile()
  106. {
  107.     for i do
  108.     test -f $i && { echo $i; return; }
  109.     done
  110.     echo $1
  111. }
  112. INETDCONF=`PickFile    $INETDCONF /etc/inetd.conf /etc/inet/inetd.conf`
  113. ALIASES=`PickFile    $ALIASES   /etc/aliases`
  114. SERVICES=`PickFile    $SERVICES  /etc/inet/services`
  115. test -f /etc/master.passwd            && PASSWD=/etc/master.passwd
  116.  
  117. #
  118. # Setup the password file manipulation functions according
  119. # to whether we have System-V style support through the
  120. # passmgmt program, or BSD style support through the chpass
  121. # program.  If neither are found, we setup functions that
  122. # will cause us to abort if we need to munge the password file.
  123. #
  124. if [ -f /bin/passmgmt -o -f /usr/sbin/passmgmt ]; then
  125.     addPasswd()
  126.     {
  127.     passmgmt -o -a -c 'Facsimile Agent' -h $4 -u $2 -g $3 $1
  128.     }
  129.     deletePasswd()
  130.     {
  131.     passmgmt -d $1
  132.     }
  133.     modifyPasswd()
  134.     {
  135.     passmgmt -m -h $4 -u $2 -o -g $3 $1
  136.     }
  137.     lockPasswd()
  138.     {
  139.     passwd -l $1
  140.     }
  141. elif [ -f /usr/bin/chpass ]; then
  142.     addPasswd()
  143.     {
  144.     chpass -a "$1:*:$2:$3::0:0:Facsimile Agent:$4:"
  145.     }
  146.     modifyPasswd()
  147.     {
  148.     chpass -a "$1:*:$2:$3::0:0:Facsimile Agent:$4:"
  149.     }
  150.     lockPasswd()
  151.     {
  152.     return 0                # entries are always locked
  153.     }
  154. elif [ -f /etc/useradd -o -f /usr/sbin/useradd ]; then
  155.     addPasswd()
  156.     {
  157.     useradd -c 'Facsimile Agent' -d $4 -u $2 -o -g $3 $1
  158.     }
  159.     deletePasswd()
  160.     {
  161.     userdel $1
  162.     }
  163.     modifyPasswd()
  164.     {
  165.     usermod -m -d $4 -u $2 -o -g $3 $1
  166.     }
  167.     lockPasswd()
  168.     {
  169.     passwd -l $1
  170.     }
  171. else
  172.     addPasswd()
  173.     {
  174.     echo "Help, I don't know how to add a passwd entry!"; exit 1
  175.     }
  176.     modifyPasswd()
  177.     {
  178.     echo "Help, I don't know how to modify a passwd entry!"; exit 1
  179.     }
  180. fi
  181.  
  182. #
  183. # Figure out which brand of echo we have and define
  184. # prompt and printf shell functions accordingly.
  185. # Note that we assume that if the System V-style
  186. # echo is not present, then the BSD printf program
  187. # is available.
  188. #
  189. if [ `echo foo\\\c`@ = "foo@" ]; then
  190.     # System V-style echo supports \r
  191.     # and \c which is all that we need
  192.     prompt()
  193.     {
  194.        echo "$* \\c"
  195.     }
  196.     printf()
  197.     {
  198.        echo "$*\\c"
  199.     }
  200. elif [ "`echo -n foo`@" = "foo@" ]; then
  201.     # BSD-style echo; use echo -n to get
  202.     # a line without the trailing newline
  203.     prompt()
  204.     {
  205.        echo -n "$* "
  206.     }
  207. else
  208.     # something else; do without
  209.     prompt()
  210.     {
  211.     echo "$*"
  212.     }
  213. fi
  214. t=`printf hello` 2>/dev/null
  215. if [ "$t" != "hello" ]; then
  216.     echo "You don't seem to have a System V-style echo command"
  217.     echo "or a BSD-style printf command.  I'm bailing out..."
  218.     exit 1
  219. fi
  220.  
  221. #
  222. # If the killall program is not present on the system
  223. # cobble together a shell function to emulate the
  224. # functionality that we need.
  225. #
  226. (killall -l >/dev/null) 2>/dev/null || {
  227.     killall()
  228.     {
  229.     # NB: ps ax should give an error on System V, so we try it first!
  230.     pid="`ps ax 2>/dev/null | grep $2 | grep -v grep | awk '{print $1;}'`"
  231.     test "$pid" ||
  232.         pid="`ps -e | grep $2 | grep -v grep | awk '{print $2;}'`"
  233.     test "$pid" && kill $1 $pid; return
  234.     }
  235. }
  236.  
  237. #
  238. # Prompt the user for a string that can not be null.
  239. #
  240. promptForNonNullStringParameter()
  241. {
  242.     x=""
  243.     while [ -z "$x" ]; do
  244.     prompt "$2 [$1]?"; read x
  245.     if [ "$x" ]; then
  246.         # strip leading and trailing white space
  247.         x=`echo "$x" | sed -e 's/^[     ]*//' -e 's/[     ]*$//'`
  248.     else
  249.         x="$1"
  250.     fi
  251.     done
  252.     param="$x"
  253. }
  254.  
  255. #
  256. # Prompt the user for a numeric value.
  257. #
  258. promptForNumericParameter()
  259. {
  260.     x=""
  261.     while [ -z "$x" ]; do
  262.     prompt "$2 [$1]?"; read x
  263.     if [ "$x" ]; then
  264.         # strip leading and trailing white space
  265.         x=`echo "$x" | sed -e 's/^[     ]*//' -e 's/[     ]*$//'`
  266.         match=`expr "$x" : "\([0-9]*\)"`
  267.         if [ "$match" != "$x" ]; then
  268.         echo ""
  269.         echo "This must be entirely numeric; please correct it."
  270.         echo ""
  271.         x="";
  272.         fi
  273.     else
  274.         x="$1"
  275.     fi
  276.     done
  277.     param="$x"
  278. }
  279.  
  280. #
  281. # Prompt the user for a C-style numeric value.
  282. #
  283. promptForCStyleNumericParameter()
  284. {
  285.     x=""
  286.     while [ -z "$x" ]; do
  287.     prompt "$2 [$1]?"; read x
  288.     if [ "$x" ]; then
  289.         # strip leading and trailing white space and C-style 0x prefix
  290.         x=`echo "$x" | sed -e 's/^[     ]*//' -e 's/[     ]*$//'`
  291.         match=`expr "$x" : "\([0-9]*\)" \| "$x" : "\(0x[0-9a-fA-F]*\)"`
  292.         if [ "$match" != "$x" ]; then
  293.         echo ""
  294.         echo "This must be entirely numeric; please correct it."
  295.         echo ""
  296.         x="";
  297.         fi
  298.     else
  299.         x="$1"
  300.     fi
  301.     done
  302.     param="$x"
  303. }
  304.  
  305. #
  306. # Start of system-related setup checking.  All this stuff
  307. # should be done outside this script, but we check here
  308. # so that it's sure to be done before starting up a fax
  309. # server process.
  310. # 
  311. echo "Verifying that your system is setup properly for fax service..."
  312.  
  313. faxUID=`grep "^$PROTOUID:" $PASSWD | cut -d: -f3`
  314. if [ -z "$faxUID" ]; then faxUID=$defPROTOUID; fi
  315. faxGID=`grep "^$PROTOGID:" $GROUP | cut -d: -f3`
  316. if [ -z "$faxGID" ]; then faxGID=$defPROTOGID; fi
  317.  
  318. #
  319. # Change the password file entry for the fax user.
  320. #
  321. fixupFaxUser()
  322. {
  323.     emsg1=`modifyPasswd $FAX $faxUID $faxGID $SPOOL 2>&1`
  324.     case $? in
  325.     0)    echo "Done, the \"$FAX\" user should now have the right user id.";;
  326.     *) cat <<-EOF
  327.     Something went wrong; the command failed with:
  328.  
  329.     "$emsg1"
  330.  
  331.     The fax server will not work correctly until the proper uid
  332.     is setup for it in the password file.  Please fix this problem
  333.     and then rerun faxaddmodem.
  334.     EOF
  335.     exit 1
  336.     ;;
  337.     esac
  338. }
  339.  
  340. #
  341. # Add a fax user to the password file and lock the
  342. # entry so that noone can login as the user.
  343. #
  344. addFaxUser()
  345. {
  346.     emsg1=`addPasswd $FAX $faxUID $faxGID $SPOOL 2>&1`
  347.     case $? in
  348.     0)  emsg2=`lockPasswd $FAX 2>&1`
  349.     case $? in
  350.     0) echo "Added user \"$FAX\" to $PASSWD.";;
  351.     *) emsg3=`deletePasswd $FAX 2>&1`
  352.        case $? in
  353.        0|9) cat <<-EOF
  354.         Failed to add user "$FAX" to $PASSWD because the
  355.         attempt to lock the password failed with:
  356.  
  357.         "$emsg2"
  358.  
  359.         Please fix this problem and rerun this script."
  360.         EOF
  361.         exit 1
  362.         ;;
  363.        *)   cat <<-EOF
  364.         You will have to manually edit $PASSWD because
  365.         after successfully adding the new user "$FAX", the
  366.         attempt to lock its password failed with:
  367.  
  368.         "$emsg2"
  369.  
  370.         and the attempt to delete the insecure passwd entry failed with:
  371.  
  372.         "$emsg3"
  373.  
  374.         To close this security hole, you should add a password
  375.         to the "$FAX" entry in the file $PASSWD, or lock this
  376.         entry with an invalid password.
  377.         EOF
  378.         ;;
  379.         esac
  380.         exit 1;;
  381.     esac;;
  382.     9)  # fax was already in $PASSWD, but not found with grep
  383.     ;;
  384.     *)  cat <<-EOF
  385.     There was a problem adding user "$FAX" to $PASSWD;
  386.     the command failed with:
  387.  
  388.     "$emsg1"
  389.  
  390.     The fax server will not work until you have corrected this problem.
  391.     EOF
  392.     exit 1;;
  393.     esac
  394. }
  395.  
  396. x=`grep "^$FAX:" $PASSWD | cut -d: -f3`
  397. if [ -z "$x" ]; then
  398.     echo ""
  399.     echo "You do not appear to have a "$FAX" user in the password file."
  400.     prompt "The fax software needs this to work properly, add it [yes]?"
  401.     read x
  402.     if [ -z "$x" -o "$x" = "y" -o "$x" = "yes" ]; then
  403.     addFaxUser
  404.     fi
  405. elif [ "$x" != "$faxUID" ]; then
  406.     echo ""
  407.     echo "It looks like you have a \"$FAX\" user in the password file,"
  408.     echo "but with a uid different than the uid for uucp.  You probably"
  409.     echo "have old fax software installed.  In order for this software"
  410.     echo "to work properly, the fax user uid must be the same as uucp."
  411.     prompt "Is it ok to change the password entry for \"$FAX\" [yes]?"
  412.     read x
  413.     if [ -z "$x" -o "$x" = "y" -o "$x" = "yes" ]; then
  414.     fixupFaxUser
  415.     fi
  416. fi
  417. #
  418. # This should only have an effect on an SGI system...
  419. # hide the fax user from pandora & co.
  420. #
  421. if [ "$OS" = "IRIX" -a -f $SGIPASSWD ]; then
  422.     x=$FAX:noshow
  423.     grep $x $SGIPASSWD >/dev/null 2>&1 ||
  424.     (echo ""; echo "Adding fax user to \"$SGIPASSWD\"."; echo $x >>$SGIPASSWD)
  425. fi
  426.  
  427. #
  428. # Make sure a service entry is present.
  429. #
  430. hasYP=`ypcat services 2>/dev/null | tail -1` 2>/dev/null
  431. x=
  432. if [ "$hasYP" ]; then
  433.     x=`ypcat services 2>/dev/null | egrep '^(flex)?fax[     ]'` 2>/dev/null
  434.     if [ -z "$x" ]; then
  435.     echo ""
  436.     echo "There does not appear to be an entry for the fax service in the YP database;"
  437.     echo "the software will not work properly without one.  Contact your administrator"
  438.     echo "to get the folllowing entry added:"
  439.     echo ""
  440.     echo "fax    4557/tcp        # FAX transmission service"
  441.     echo ""
  442.     exit 1
  443.     fi
  444. else
  445.     x=`egrep '^(flex)?fax[     ]' $SERVICES 2>/dev/null` 2>/dev/null
  446.     if [ -z "$x" ]; then
  447.     echo ""
  448.     echo "There does not appear to be an entry for the fax service in the $SERVICES file;"
  449.     prompt "should an entry be added to $SERVICES [yes]?"
  450.     read x
  451.     if [ "$x" = "" -o "$x" = "y" -o "$x" = "yes" ]; then
  452.         echo "fax        4557/tcp        # FAX transmission service" >>$SERVICES
  453.     fi
  454.     fi
  455. fi
  456.  
  457. #
  458. # Check that inetd is setup to provide service.
  459. #
  460. E="fax    stream    tcp    nowait    $FAX    $SERVERDIR/faxd.recv    faxd.recv"
  461. test -f $INETDCONF && {
  462.     egrep "^(flex)?fax[     ]*stream[     ]*tcp" $INETDCONF >/dev/null 2>&1 ||
  463.     (echo ""
  464.      echo "There is no entry for the fax service in \"$INETDCONF\";"
  465.      prompt "should one be added [yes]?"
  466.      read x
  467.      if [ "$x" = "" -o "$x" = "y" -o "$x" = "yes" ]; then
  468.     echo "$E" >>$INETDCONF;
  469.     if killall -HUP inetd 2>/dev/null; then
  470.         echo "Poked inetd so that it re-reads the configuration file."
  471.     else
  472.         echo "Beware, you may need to send a HUP signal to inetd."
  473.     fi
  474.      fi
  475.     )
  476. }
  477.  
  478. #
  479. # Check for a FaxMaster entry for sending mail.
  480. #
  481. x=`ypcat -k aliases 2>/dev/null | grep -i '^faxmaster'` 2>/dev/null
  482. if [ -z "$x" -a -f $ALIASES ]; then
  483.     x=`grep -i '^faxmaster' $ALIASES`
  484. fi
  485. if [ -z "$x" ]; then
  486.     echo ""
  487.     echo "There does not appear to be an entry for the FaxMaster either in"
  488.     echo "the yellow pages database or in the $ALIASES file;"
  489.     prompt "should an entry be added to $ALIASES [yes]?"
  490.     read x
  491.     if [ "$x" = "" -o "$x" = "y" -o "$x" = "yes" ]; then
  492.     promptForNonNullStringParameter "${USER:-root}" \
  493.        "Users to receive fax-related mail"
  494.     (echo "# alias for notification messages from FlexFAX servers";
  495.      echo "FaxMaster: $param") >>$ALIASES
  496.     if newaliases 2>/dev/null; then
  497.         echo "Rebuilt $ALIASES database."
  498.     else
  499.         echo "Can not find newaliases to rebuild $ALIASES;"
  500.         echo "you will have to do it yourself."
  501.     fi
  502.     fi
  503. fi
  504.  
  505.  
  506. echo ""
  507. echo "Done verifying system setup."
  508. echo ""
  509. # End of system-related setup checking
  510.  
  511. while [ -z "$TTY" -o ! -c /dev/$TTY ]; do
  512.     if [ "$TTY" != "" ]; then
  513.     echo "/dev/$TTY is not a terminal device."
  514.     fi
  515.     prompt "Serial port that modem is connected to [$TTY]?"; read TTY
  516. done
  517.  
  518. JUNK="$OUT"
  519. trap "rm -f \$JUNK; exit 1" 0 1 2 15
  520.  
  521. if [ ! -d $LOCKDIR ]; then
  522.     prompt "Hmm, uucp lock files are not in \"$LOCKDIR\", where are they?"
  523.     read x
  524.     while [ ! -d $x ]; do
  525.     prompt "Nope, \"$x\" is not a directory; try again:"
  526.     read x
  527.     done
  528.     LOCKDIR=$x
  529. fi
  530.  
  531. #
  532. # Try to deduce if the tty devices are named in the SGI
  533. # sense (ttyd<port>, ttym<port>, and ttyf<port>) or the
  534. # way that everyone else seems to do it--tty<port>
  535. #
  536. # (I'm sure that someone will tell me there is another way as well.)
  537. #
  538. case "$OS" in
  539. IRIX)
  540.     PORT=`expr $TTY : 'tty.\(.*\)'`
  541.     for x in f m d; do
  542.     LOCKX="$LOCKX $LOCKDIR/LCK..tty$x${PORT}"
  543.     done
  544.     DEVS="/dev/ttyd${PORT} /dev/ttym${PORT} /dev/ttyf${PORT}"
  545.     #
  546.     # NB: we use ttyd* device names in the following
  547.     # work so that we are not stopped by a need for DCD.
  548.     #
  549.     tdev=/dev/ttyd${PORT}
  550.     #
  551.     # No current SGI equipment supports rates >38400
  552.     #
  553.     SPEEDS="38400 19200 9600 4800 2400 1200"
  554.     ;;
  555. BSDi|BSD/386|386bsd|386BSD)
  556.     PORT=`expr $TTY : 'com\(.*\)'`
  557.     LOCKX="$LOCKDIR/LCK..$TTY"
  558.     DEVS=/dev/$TTY
  559.     tdev=/dev/$TTY
  560.     ;;
  561. SunOS|Linux|ULTRIX|HP-UX|FreeBSD)
  562.     PORT=`expr $TTY : 'tty\(.*\)'`
  563.     LOCKX="$LOCKDIR/LCK..$TTY"
  564.     DEVS=/dev/$TTY
  565.     tdev=/dev/$TTY
  566.     ;;
  567. svr4)
  568.     PORT=`expr $TTY : 'term\/\(.*\)' \| $TTY`    # Usual
  569.     PORT=`expr $PORT : 'cua\/\(.*\)' \| $PORT`    # Solaris
  570.     PORT=`expr $PORT : 'tty\(.*\)' \| $PORT`    # Old-style
  571.     DEVS=/dev/$TTY
  572.     tdev=/dev/$TTY
  573.     LOCKX="$LOCKDIR/`$SVR4UULCKN $DEVS`" || {
  574.     echo "Sorry, I cannot determine the UUCP lock file name for $DEVS"
  575.     exit 1
  576.     }
  577.     ;;
  578. *)
  579.     echo "Beware, I am guessing the tty naming conventions on your system:"
  580.     PORT=`expr $TTY : 'tty\(.*\)'`;    echo "Serial port: $PORT"
  581.     LOCKX="$LOCKDIR/LCK..$TTY";        echo "UUCP lock file: $LOCKX"
  582.     DEVS=/dev/$TTY; tdev=/dev/$TTY;    echo "TTY device: $DEVS"
  583.     ;;
  584. esac
  585. DEVID="`echo $TTY | tr '/' '_'`"
  586. CONFIG=$CPATH.$DEVID
  587.  
  588. #
  589. # Check that device is not currently being used.
  590. #
  591. for x in $LOCKX; do
  592.     if [ -f $x ]; then
  593.     echo "Sorry, the device is currently in use by another program."
  594.     exit 1
  595.     fi
  596. done
  597.  
  598. #
  599. # Look for conflicting configuration stuff.
  600. #
  601. OLDCONFIG=""
  602.  
  603. checkPort()
  604. {
  605.     devID="`echo $1 | tr '/' '_'`"
  606.     if [ -f $CPATH.$devID -a -p $SPOOL/FIFO.$devID ]; then
  607.     echo "There appears to be a modem already setup on $devID,"
  608.     prompt "is this to be replaced [yes]?"
  609.     read x;
  610.     if [ "$x" = "n" -o "$x" = "no" ]; then
  611.         echo "Sorry, but you can not configure multiple servers on"
  612.         echo "the same serial port."
  613.         exit 1
  614.  
  615.     fi
  616.     echo "Removing old FIFO special file $SPOOL/FIFO.$devID."
  617.     $QUIT $devID >/dev/null 2>&1; rm -f $SPOOL/FIFO.$devID
  618.     OLDCONFIG=$CPATH.$devID
  619.     fi
  620. }
  621.  
  622. if [ "$OS" = "IRIX" ]; then
  623.     case $TTY in
  624.     ttym${PORT}) checkPort ttyd${PORT}; checkPort ttyf${PORT};;
  625.     ttyf${PORT}) checkPort ttym${PORT}; checkPort ttyd${PORT};;
  626.     ttyd${PORT}) checkPort ttym${PORT}; checkPort ttyf${PORT};;
  627.     esac
  628. fi
  629. $QUIT $DEVID >/dev/null 2>&1; sleep 1        # shutdown existing server
  630.  
  631. #
  632. # Lock the device for later use when deducing the modem type.
  633. #
  634. JUNK="$JUNK $LOCKX"
  635.  
  636. LOCKSTR=`expr "         $$" : '.*\(..........\)'`
  637. # lock the device by all of its names
  638. for x in $LOCKX; do
  639.     echo "$LOCKSTR" > $x
  640. done
  641. # zap any gettys or other users
  642. fuser -k $DEVS >/dev/null 2>&1 || {
  643.     cat<<EOF
  644. Hmm, there does not appear to be an fuser command on your machine.
  645. This means that I am unable to insure that all processes using the
  646. modem have been killed.  I will keep going, but beware that you may
  647. have competition for the modem.
  648. EOF
  649. }
  650.  
  651. cat<<EOF
  652.  
  653. Ok, time to setup a configuration file for the modem.  The manual
  654. page config(4F) may be useful during this process.  Also be aware
  655. that at any time you can safely interrupt this procedure.
  656.  
  657. EOF
  658.  
  659. getParameter()
  660. {
  661.     param=`grep "^$1:" $2 | sed -e 's/[     ]*#.*//' -e 's/.*:[     ]*//'`
  662. }
  663.  
  664. #
  665. # Get the server config values
  666. # from the prototype config file.
  667. #
  668. getServerProtoParameters()
  669. {
  670.     file=$1
  671.     getParameter FAXNumber $file;        protoFAXNumber="$param"
  672.     getParameter CountryCode $file;        protoCountryCode="$param"
  673.     getParameter AreaCode $file;        protoAreaCode="$param"
  674.     getParameter LongDistancePrefix $file;  protoLongDistancePrefix="$param"
  675.     getParameter InternationalPrefix $file; protoInternationalPrefix="$param"
  676.     getParameter DialStringRules $file;        protoDialStringRules="$param"
  677.     getParameter ServerTracing $file;        protoServerTracing="$param"
  678.     getParameter SessionTracing $file;        protoSessionTracing="$param"
  679.     getParameter RecvFileMode $file;        protoRecvFileMode="$param"
  680.     getParameter LogFileMode $file;        protoLogFileMode="$param"
  681.     getParameter DeviceMode $file;        protoDeviceMode="$param"
  682.     getParameter RingsBeforeAnswer $file;   protoRingsBeforeAnswer="$param"
  683.     getParameter SpeakerVolume $file;
  684.     # convert old numeric style
  685.     case "$param" in
  686.     0)    protoSpeakerVolume="off";;
  687.     1)    protoSpeakerVolume="low";;
  688.     2)    protoSpeakerVolume="quiet";;
  689.     3)    protoSpeakerVolume="medium";;
  690.     4)    protoSpeakerVolume="high";;
  691.     *)    protoSpeakerVolume="$param";;
  692.     esac
  693.     # convert old-style UseDialPrefix & DialingPrefix to ModemDialCmd fmt
  694.     getParameter UseDialPrefix $file;
  695.     case "$param" in
  696.     [yY]es|[oO]n) getParameter DialingPrefix $file; DialingPrefix="$param";;
  697.     *)                              DialingPrefix="";;
  698.     esac
  699.     # convert old-style GettyAllowed & GettySpeed to GettyArgs
  700.     getParameter GettyAllowed $file;
  701.     case "$param" in
  702.     [yY]es|[oO]n) getParameter GettySpeed $file; protoGettyArgs="$param";;
  703.     *)          getParameter GettyArgs $file;  protoGettyArgs="$param";;
  704.     esac
  705.     # convert old-style yes/no for QualifyTSI
  706.     getParameter QualifyTSI $file;
  707.     case "$param" in
  708.     [yY]es|[oO]n) protoQualifyTSI="etc/tsi";;
  709.     *)          protoQualifyTSI="$param";;
  710.     esac
  711.     getParameter JobReqBusy $file;    protoJobReqBusy="$param"
  712.     getParameter JobReqNoCarrier $file;    protoJobReqNoCarrier="$param"
  713.     getParameter JobReqNoAnswer $file;    protoJobReqNoAnswer="$param"
  714.     getParameter JobReqProto $file;    protoJobReqProto="$param"
  715.     getParameter JobReqOther $file;    protoJobReqOther="$param"
  716.     getParameter UUCPLockTimeout $file;    protoUUCPLockTimeout="$param"
  717.     getParameter PollModemWait $file;    protoPollModemWait="$param"
  718.     getParameter PollLockWait $file;    protoPollLockWait="$param"
  719. }
  720.  
  721. setupServerParameters()
  722. {
  723.     FAXNumber="$protoFAXNumber"
  724.     AreaCode="$protoAreaCode"
  725.     CountryCode="${protoCountryCode:-1}"
  726.     LongDistancePrefix="${protoLongDistancePrefix:-1}"
  727.     InternationalPrefix="${protoInternationalPrefix:-011}"
  728.     DialStringRules="${protoDialStringRules:-etc/dialrules}"
  729.     ServerTracing="${protoServerTracing:-1}"
  730.     SessionTracing="${protoSessionTracing:-11}"
  731.     RecvFileMode="${protoRecvFileMode:-0600}"
  732.     LogFileMode="${protoLogFileMode:-0600}"
  733.     DeviceMode="${protoDeviceMode:-0600}"
  734.     RingsBeforeAnswer="${protoRingsBeforeAnswer:-1}"
  735.     SpeakerVolume="${protoSpeakerVolume:-off}"
  736.     GettyArgs="$protoGettyArgs"
  737.     QualifyTSI="$protoQualifyTSI"
  738.     JobReqBusy="$protoJobReqBusy"
  739.     JobReqNoCarrier="$protoJobReqNoCarrier"
  740.     JobReqNoAnswer="$protoJobReqNoAnswer"
  741.     JobReqProto="$protoJobReqProto"
  742.     JobReqOther="$protoJobReqOther"
  743.     UUCPLockTimeout="$protoUUCPLockTimeout"
  744.     PollModemWait="$protoPollModemWait"
  745.     PollLockWait="$protoPollLockWait"
  746. }
  747.  
  748. #
  749. # Append a sed command to the ServerCmds if we need to
  750. # alter the existing configuration parameter.  Note that
  751. # we handle the case where there are embedded blanks or
  752. # tabs by enclosing the string in quotes.
  753. #
  754. addServerSedCmd()
  755. {
  756.     test "$1" != "$2" && {
  757.     # escape backslashes to counteract shell parsing and sed magic chars
  758.     x=`echo "$2" | sed 's/[&\\\\"]/\\\\&/g'`
  759.     if [ `expr "$2" : "[^\"].*[ ]"` = 0 ]; then
  760.         ServerCmds="$ServerCmds -e '/^$3:/s;\(:[     ]*\).*;\1$x;'"
  761.     else
  762.         ServerCmds="$ServerCmds -e '/^$3:/s;\(:[     ]*\).*;\1\"$x\";'"
  763.     fi
  764.     }
  765. }
  766.  
  767. #
  768. # Setup the sed commands for crafting the configuration file:
  769. #
  770. makeSedServerCommands()
  771. {
  772.     ServerCmds=""
  773.     addServerSedCmd "$protoFAXNumber"        "$FAXNumber"    FAXNumber
  774.     addServerSedCmd "$protoAreaCode"        "$AreaCode"    AreaCode
  775.     addServerSedCmd "$protoCountryCode"        "$CountryCode"    CountryCode
  776.     addServerSedCmd "$protoLongDistancePrefix"    "$LongDistancePrefix" \
  777.     LongDistancePrefix
  778.     addServerSedCmd "$protoInternationalPrefix"    "$InternationalPrefix" \
  779.     InternationalPrefix
  780.     addServerSedCmd "$protoDialStringRules"    "$DialStringRules" \
  781.     DialStringRules
  782.     addServerSedCmd "$protoServerTracing"    "$ServerTracing" \
  783.     ServerTracing
  784.     addServerSedCmd "$protoSessionTracing"    "$SessionTracing" \
  785.     SessionTracing
  786.     addServerSedCmd "$protoRecvFileMode"    "$RecvFileMode"    RecvFileMode
  787.     addServerSedCmd "$protoLogFileMode"        "$LogFileMode"    LogFileMode
  788.     addServerSedCmd "$protoDeviceMode"        "$DeviceMode"    DeviceMode
  789.     addServerSedCmd "$protoRingsBeforeAnswer"    "$RingsBeforeAnswer" \
  790.     RingsBeforeAnswer
  791.     addServerSedCmd "$protoSpeakerVolume"    "$SpeakerVolume" \
  792.     SpeakerVolume
  793.     addServerSedCmd "$protoGettyArgs"        "$GettyArgs"    GettyArgs
  794.     addServerSedCmd "$protoQualifyTSI"        "$QualifyTSI"    QualifyTSI
  795.     addServerSedCmd "$protoJobReqBusy"        "$JobReqBusy" \
  796.        JobReqBusy
  797.     addServerSedCmd "$protoJobReqNoCarrier"    "$JobReqNoCarrier" \
  798.     JobReqNoCarrier
  799.     addServerSedCmd "$protoJobReqNoAnswer"    "$JobReqNoAnswer" \
  800.     JobReqNoAnswer
  801.     addServerSedCmd "$protoJobReqProto"        "$JobReqProto" \
  802.        JobReqProto
  803.     addServerSedCmd "$protoJobReqOther"        "$JobReqOther" \
  804.        JobReqOther
  805.     addServerSedCmd "$protoUUCPLockTimeout"    "$UUCPLockTimeout" \
  806.     UUCPLockTimeout
  807.     addServerSedCmd "$protoPollModemWait"    "$PollModemWait" \
  808.     PollModemWait
  809.     addServerSedCmd "$protoPollLockWait"    "$PollLockWait" \
  810.        PollLockWait
  811. }
  812.  
  813. #
  814. # Prompt the user for volume setting.
  815. #
  816. promptForSpeakerVolume()
  817. {
  818.     x=""
  819.     while [ -z "$x" ]; do
  820.     prompt "Modem speaker volume [$SpeakerVolume]?"; read x
  821.     if [ "$x" != "" ]; then
  822.         # strip leading and trailing white space
  823.         x=`echo "$x" | sed -e 's/^[     ]*//' -e 's/[     ]*$//'`
  824.         case "$x" in
  825.         [oO]*)    x="off";;
  826.         [lL]*)    x="low";;
  827.         [qQ]*)    x="quiet";;
  828.         [mM]*)    x="medium";;
  829.         [hH]*)    x="high";;
  830.         *)
  831. cat <<EOF
  832.  
  833. "$x" is not a valid speaker volume setting; use one
  834. of: "off", "low", "quiet", "medium", and "high".
  835. EOF
  836.         x="";;
  837.         esac
  838.     else
  839.         x="$SpeakerVolume"
  840.     fi
  841.     done
  842.     SpeakerVolume="$x"
  843. }
  844.  
  845. #
  846. # Verify that the fax number, area code, and country
  847. # code jibe.  Perhaps this is too specific to the USA?
  848. #
  849. checkFaxNumber()
  850. {
  851.     pat="[\"]*\+$CountryCode[-. ]*$AreaCode[-. ]*[0-9][- .0-9]*[\"]*"
  852.     match=`expr "$FAXNumber" : "\($pat\)"`
  853.     if [ "$match" != "$FAXNumber" ]; then
  854.     cat<<EOF
  855.  
  856. Your facsimile phone number ($FAXNumber) does not agree with your
  857. country code ($CountryCode) or area code ($AreaCode).  The number
  858. should be a fully qualified international dialing number of the form:
  859.  
  860.     +$CountryCode $AreaCode <local phone number>
  861.  
  862. Spaces, hyphens, and periods can be included for legibility.  For example,
  863.  
  864.     +$CountryCode.$AreaCode.555.1212
  865.  
  866. is a possible phone number (using your country and area codes).
  867. EOF
  868.     ok="no";
  869.     fi
  870. }
  871.  
  872. #
  873. # Verify that a number is octal and if not, add a prefixing "0".
  874. #
  875. checkOctalNumber()
  876. {
  877.     param=$1
  878.     if [ "`expr "$param" : '\(.\)'`" != "0" ]; then
  879.     param="0${param}"
  880.     return 0
  881.     else
  882.     return 1
  883.     fi
  884. }
  885.  
  886. #
  887. # Verify that the dial string rules file exists.
  888. #
  889. checkDialStringRules()
  890. {
  891.     if [ ! -f $SPOOL/$DialStringRules ]; then
  892.     cat<<EOF
  893.  
  894. Warning, the dial string rules file,
  895.  
  896.     $SPOOL/$DialStringRules
  897.  
  898. does not exist, or is not a plain file.  The rules file
  899. must reside in the $SPOOL directory tree.
  900. EOF
  901.     ok="no";
  902.     fi
  903. }
  904.  
  905. #
  906. # Print the current server configuration parameters.
  907. #
  908. printServerConfig()
  909. {
  910.     cat<<EOF
  911.  
  912. The server configuration parameters are:
  913.  
  914. AreaCode:        $AreaCode
  915. CountryCode:        $CountryCode
  916. FAXNumber:        $FAXNumber
  917. LongDistancePrefix:    $LongDistancePrefix
  918. InternationalPrefix:    $InternationalPrefix
  919. DialStringRules:    $DialStringRules
  920. ServerTracing:        $ServerTracing
  921. SessionTracing:        $SessionTracing
  922. RecvFileMode:        $RecvFileMode
  923. LogFileMode:        $LogFileMode
  924. DeviceMode:        $DeviceMode
  925. RingsBeforeAnswer:    $RingsBeforeAnswer
  926. SpeakerVolume:        $SpeakerVolume
  927. EOF
  928.     test "$protoGettyArgs" &&
  929.     echo "GettyArgs:        $GettyArgs"
  930.     test "$protoQualifyTSI" &&
  931.     echo "QualifyTSI:        $QualifyTSI"
  932.     test "$protoJobReqBusy" &&
  933.     echo "JobReqBusy:        $JobReqBusy"
  934.     test "$protoJobReqNoCarrier" &&
  935.     echo "JobReqNoCarrier:    $JobReqNoCarrier"
  936.     test "$protoJobReqNoAnswer" &&
  937.     echo "JobReqNoAnswer:        $JobReqNoAnswer"
  938.     test "$protoJobReqProto" &&
  939.     echo "JobReqProto:        $JobReqProto"
  940.     test "$protoJobReqOther" &&
  941.     echo "JobReqOther:        $JobReqOther"
  942.     test "$protoUUCPLockTimeout" &&
  943.     echo "UUCPLockTimeout:    $UUCPLockTimeout"
  944.     test "$protoPollModemWait" &&
  945.     echo "PollModemWait:        $PollModemWait"
  946.     test "$protoPollLockWait" &&
  947.     echo "PollLockWait:        $PollLockWait"
  948.     echo ""
  949. }
  950.  
  951. if [ -f $CONFIG -o -z "$OLDCONFIG" ]; then
  952.     OLDCONFIG=$CONFIG
  953. fi
  954. if [ -f $OLDCONFIG ]; then
  955.     echo "Hey, there is an existing config file "$OLDCONFIG"..."
  956.     getServerProtoParameters $OLDCONFIG
  957.     ok="skip"                # skip prompting first time through
  958. else
  959.     echo "No existing configuration, let's do this from scratch."
  960.     echo ""
  961.     getServerProtoParameters $CPATH.skel # get from skeletal file
  962.     ok="prompt"                # prompt for parameters
  963. fi
  964. setupServerParameters            # record prototype & setup defaults
  965.  
  966. if [ -z "$FAXNumber" ]; then
  967.     FAXNumber="+$CountryCode $AreaCode 555-1212"
  968. fi
  969. #
  970. # Prompt user for server-related configuration parameters
  971. # and do consistency checking on what we get.
  972. #
  973. while [ "$ok" != "" -a "$ok" != "y" -a "$ok" != "yes" ]; do
  974.     if [ "$ok" != "skip" ]; then
  975.     promptForNumericParameter "$CountryCode" \
  976.         "Country code"; CountryCode=$param;
  977.     promptForNumericParameter "$AreaCode" \
  978.         "Area code"; AreaCode=$param;
  979.     promptForNonNullStringParameter "$FAXNumber" \
  980.         "Phone number of fax modem"; FAXNumber=$param;
  981.     promptForNumericParameter "$LongDistancePrefix" \
  982.         "Long distance dialing prefix"; LongDistancePrefix=$param;
  983.     promptForNumericParameter "$InternationalPrefix" \
  984.         "International dialing prefix"; InternationalPrefix=$param;
  985.     promptForNonNullStringParameter "$DialStringRules" \
  986.         "Dial string rules file"; DialStringRules=$param;
  987.     promptForCStyleNumericParameter "$ServerTracing" \
  988.         "Tracing during normal server operation"; ServerTracing=$param;
  989.     promptForCStyleNumericParameter "$SessionTracing" \
  990.         "Tracing during send and receive sessions"; SessionTracing=$param;
  991.     promptForNumericParameter "$RecvFileMode" \
  992.         "Protection mode for received facsimile"; RecvFileMode=$param;
  993.     promptForNumericParameter "$LogFileMode" \
  994.         "Protection mode for session logs"; LogFileMode=$param;
  995.     promptForNumericParameter "$DeviceMode" \
  996.         "Protection mode for $TTY"; DeviceMode=$param;
  997.     promptForNumericParameter "$RingsBeforeAnswer" \
  998.         "Rings to wait before answering"; RingsBeforeAnswer=$param;
  999.     promptForSpeakerVolume;
  1000.     test "$protoGettyArgs" && {
  1001.         promptForNonNullStringParameter "$GettyArgs" \
  1002.         "Command line arguments to getty program"; GettyArgs="$param";
  1003.     }
  1004.     test "$protoQualifyTSI"    && {
  1005.         promptForNonNullStringParameter "$QualifyTSI" \
  1006.         "Relative pathname of TSI patterns file";
  1007.         QualifyTSI="$param";
  1008.     }
  1009.     test "$protoJobReqBusy"    && {
  1010.         promptForCStyleNumericParameter "$JobReqBusy" \
  1011.         "Job requeue interval on BUSY status (secs)";
  1012.         JobReqBusy=$param;
  1013.     }
  1014.     test "$protoJobReqNoCarrier" && {
  1015.         promptForCStyleNumericParameter "$JobReqNoCarrier" \
  1016.         "Job requeue interval on NO CARRIER status (secs)";
  1017.         JobReqNoCarrier=$param;
  1018.     }
  1019.     test "$protoJobReqNoAnswer" && {
  1020.         promptForCStyleNumericParameter "$JobReqNoAnswer" \
  1021.         "Job requeue interval on NO ANSWER status (secs)";
  1022.         JobReqNoAnswer=$param;
  1023.     }
  1024.     test "$protoJobReqProto" && {
  1025.         promptForCStyleNumericParameter "$JobReqProto" \
  1026.         "Job requeue interval on protocol error (secs)";
  1027.         JobReqProto=$param;
  1028.     }
  1029.     test "$protoJobReqOther" && {
  1030.         promptForCStyleNumericParameter "$JobReqOther" \
  1031.         "Job requeue interval for \"other\" sorts of problems (secs)";
  1032.         JobReqOther=$param;
  1033.     }
  1034.     test "$protoUUCPLockTimeout" && {
  1035.         promptForCStyleNumericParameter "$UUCPLockTimeout" \
  1036.         "UUCP lock file timeout (secs)";
  1037.         UUCPLockTimeout=$param;
  1038.     }
  1039.     test "$protoPollModemWait" && {
  1040.         promptForCStyleNumericParameter "$PollModemWait" \
  1041.         "Polling interval for modem-wait state (secs)";
  1042.         PollModemWait=$param;
  1043.     }
  1044.     test "$protoPollLockWait" && {
  1045.         promptForCStyleNumericParameter "$PollLockWait" \
  1046.         "Polling interval for lock-wait state (secs)";
  1047.         PollLockWait=$param;
  1048.     }
  1049.     fi
  1050.     checkOctalNumber $RecvFileMode &&    RecvFileMode=$param
  1051.     checkOctalNumber $LogFileMode &&    LogFileMode=$param
  1052.     checkOctalNumber $DeviceMode &&    DeviceMode=$param
  1053.     checkDialStringRules;
  1054.     checkFaxNumber;
  1055.     printServerConfig; prompt "Are these ok [yes]?"; read ok
  1056. done
  1057.  
  1058. #
  1059. # We've got all the server-related parameters, now for the modem ones.
  1060. #
  1061.  
  1062. cat<<EOF
  1063.  
  1064. Now we are going to probe the tty port to figure out the type
  1065. of modem that is attached.  This takes a few seconds, so be patient.
  1066. Note that if you do not have the modem cabled to the port, or the
  1067. modem is turned off, this may hang (just go and cable up the modem
  1068. or turn it on, or whatever).
  1069. EOF
  1070.  
  1071. if [ $OS = "SunOS" ]; then
  1072.     #
  1073.     # Sun systems have a command for manipulating software
  1074.     # carrier on a terminal line.  Set or reset carrier
  1075.     # according to the type of tty device being used.
  1076.     #
  1077.     case $TTY in
  1078.     tty*) ttysoftcar -y $TTY;;
  1079.     cua*) ttysoftcar -n $TTY;;
  1080.     esac
  1081. fi
  1082.  
  1083. if [ -x ${ONDELAY} ]; then
  1084.     onDev() {
  1085.     if [ "$1" = "-c" ]; then
  1086.         shift; catpid=`${ONDELAY} $tdev sh -c "$* >$OUT" & echo $!`
  1087.     else
  1088.         ${ONDELAY} $tdev sh -c "$*"
  1089.     fi
  1090.     }
  1091. else
  1092. cat<<'EOF'
  1093.  
  1094. The "ondelay" program to open the device without blocking is not
  1095. present.  We're going to try to continue without it; let's hope that
  1096. the serial port won't block waiting for carrier...
  1097. EOF
  1098.     onDev() {
  1099.     if [ "$1" = "-c" ]; then
  1100.         shift; catpid=`sh <$tdev >$tdev -c "$* >$OUT" & echo $!`
  1101.     else
  1102.         sh <$tdev >$tdev -c "$*"
  1103.     fi
  1104.     }
  1105. fi
  1106.  
  1107. case $OS in
  1108. *bsd*|*BSD*)    STTY="stty -f $tdev";;
  1109. *)        STTY=stty;;
  1110. esac
  1111.  
  1112. #
  1113. # Send each command in SendString to the modem and collect
  1114. # the result in $OUT.  Read this very carefully.  It's got
  1115. # a lot of magic in it!
  1116. #
  1117. SendToModem()
  1118. {
  1119.     onDev $STTY 0                # reset the modem (hopefully)
  1120.     onDev -c "$STTY clocal && exec $CAT $tdev"    # start listening for output
  1121.     sleep 3                    # let listener open dev first
  1122.     onDev $STTY -echo -icrnl -ixon -ixoff -isig clocal $SPEED; sleep 1
  1123.     # NB: merging \r & ATQ0 causes some modems problems
  1124.     printf "\r" >$tdev; sleep 1;        # force consistent state
  1125.     printf "ATQ0V1E1\r" >$tdev; sleep 1;    # enable echo and result codes
  1126.     for i in $*; do
  1127.     printf "$i\r" >$tdev; sleep 1;
  1128.     done
  1129.     kill -9 $catpid; catpid=
  1130.     # NB: [*&\\\\$] must have the "$" last for AIX (yech)
  1131.     pat=`echo "$i"|sed -e 's/[*&\\\\$]/\\\\&/g'` # escape regex metacharacters
  1132.     RESPONSE=`tr -d '\015' < $OUT | \
  1133.     sed -n "/$pat/{n;s/ *$//;p;q;}" | sed 's/+F.*=//'`
  1134. }
  1135.  
  1136. echo ""
  1137. if [ -z "$SPEED" ]; then
  1138.     #
  1139.     # Probe for the highest speed at which the modem
  1140.     # responds to "AT" with "OK".
  1141.     #
  1142.     printf "Probing for best speed to talk to modem:"
  1143.     for SPEED in $SPEEDS
  1144.     do
  1145.     printf " $SPEED"
  1146.     SendToModem "AT" >/dev/null 2>&1
  1147.     sleep 1
  1148.     RESULT=`tr -d "\015" < $OUT | tail -1`
  1149.     test "$RESULT" = "OK" && break;
  1150.     done
  1151.     if [ "$RESULT" != "OK" ]; then
  1152.     echo ""
  1153.     echo "Unable to deduce DTE-DCE speed; check that you are using the"
  1154.     echo "correct device and/or that your modem is setup properly.  If"
  1155.     echo "all else fails, try the -s option to lock the speed."
  1156.     exit 1
  1157.     fi
  1158.     echo " OK."
  1159. else
  1160.     echo "Using user-specified $SPEED to talk to modem."
  1161. fi
  1162. RESULT="";
  1163. while [ -z "$RESULT" ]; do
  1164.     #
  1165.     # This goes in the background while we try to
  1166.     # reset the modem.  If something goes wrong, it'll
  1167.     # nag the user to check on the problem.
  1168.     #
  1169.     (trap 0 1 2 15;
  1170.      while true; do
  1171.     sleep 10;
  1172.     echo ""
  1173.     echo "Hmm, something seems to be hung, check your modem eh?"
  1174.      done)& nagpid=$!
  1175.     trap "rm -f \$JUNK; kill $nagpid \$catpid; exit 1" 0 1 2 15
  1176.  
  1177.     SendToModem "AT+FCLASS=?"             # ask for class support
  1178.  
  1179.     kill $nagpid
  1180.     trap "rm -f \$JUNK; test \"\$catpid\" && kill \$catpid; exit 1" 0 1 2 15
  1181.     sleep 1
  1182.  
  1183.     RESULT=`tr -d "\015" < $OUT | tail -1`
  1184.     if [ -z "$RESPONSE" ]; then
  1185.     echo ""
  1186.     echo "There was no response from the modem.  Perhaps the modem is"
  1187.     echo "turned off or the cable between the modem and host is not"
  1188.     echo "connected.  Please check the modem and hit a carriage return"
  1189.     prompt "when you are ready to try again:"
  1190.     read x
  1191.     fi
  1192. done
  1193.  
  1194. ModemType="" Manufacturer="" Model="" ProtoType="config.skel"
  1195.  
  1196. #
  1197. # Select a configuration file for a modem based on the
  1198. # deduced modem type.  Each routine below sends a set
  1199. # of commands to the modem to figure out the modem model
  1200. # and manufacturer and then compares them against the
  1201. # set of known values in associated config files.
  1202. # Note that this is done with a tricky bit of shell
  1203. # hacking--generating a case statement that is then
  1204. # eval'dwith the result being the setup of the
  1205. # ProtoType shell variable.
  1206. #
  1207. configureClass2Modem()
  1208. {
  1209.     ModemType=Class2
  1210.     echo "Hmm, this looks like a Class 2 modem."
  1211.  
  1212.     SendToModem "AT+FCLASS=2" "AT+FMFR?"
  1213.     Manufacturer=$RESPONSE
  1214.     echo "Modem manufacturer is \"$Manufacturer\"."
  1215.  
  1216.     SendToModem "AT+FCLASS=2" "AT+FMDL?"
  1217.     Model=$RESPONSE
  1218.     echo "Modem model is \"$Model\"."
  1219.  
  1220.     eval `(cd $MODEMCONFIG; \
  1221.     grep 'CONFIG:[     ]*CLASS2' config.* |\
  1222.     awk -F: '
  1223.         BEGIN { print "case \"$Manufacturer-$Model\" in" }
  1224.         { print $4 ") ProtoType=" $1 ";;" }
  1225.         END { print "*) ProtoType=config.class2;;"; print "esac" }
  1226.     ')`
  1227. }
  1228.  
  1229. #
  1230. # As above, but for Class 2.0 modems.
  1231. #
  1232. configureClass2dot0Modem()
  1233. {
  1234.     ModemType=Class20
  1235.     echo "Hmm, this looks like a Class 2.0 modem."
  1236.     #
  1237.     SendToModem "AT+FCLASS=2.0" "AT+FMI?"
  1238.     Manufacturer=$RESPONSE
  1239.     echo "Modem manufacturer is \"$Manufacturer\"."
  1240.  
  1241.     SendToModem "AT+FCLASS=2.0" "AT+FMM?"
  1242.     Model=$RESPONSE
  1243.     echo "Modem model is \"$Model\"."
  1244.  
  1245.     eval `(cd $MODEMCONFIG; \
  1246.     grep 'CONFIG:[     ]*CLASS2.0' config.* |\
  1247.     awk -F: '
  1248.         BEGIN { print "case \"$Manufacturer-$Model\" in" }
  1249.         { print $4 ") ProtoType=" $1 ";;" }
  1250.         END { print "*) ProtoType=config.class2.0;;"; print "esac" }
  1251.     ')`
  1252. }
  1253.  
  1254. #
  1255. # Class 1 modems are handled a bit differently as
  1256. # there are no commands to obtain the manufacturer
  1257. # and model.  Instead we use ATI0 to get the product
  1258. # code and then compare it against the set of known
  1259. # values in the config files.
  1260. #
  1261. configureClass1Modem()
  1262. {
  1263.     ModemType=Class1 Manufacturer=Unknown Model=Unknown
  1264.     echo "Hmm, this looks like a Class 1 modem."
  1265.  
  1266.     SendToModem "ATI0"
  1267.     echo "Product code is \"$RESPONSE\"."
  1268.  
  1269.     eval `(cd $MODEMCONFIG; grep 'CONFIG:[     ]*CLASS1' config.*) |\
  1270.     sed 's/:[     ]*/:/g' |\
  1271.     awk -F: '
  1272. BEGIN    { proto = "" }
  1273. $4 == C    { if (proto != "") {
  1274.           print "echo \"Warning, multiple configuration files exist for this modem,\";"
  1275.           print "echo \"   the file " $1 " is ignored.\";"
  1276.       } else
  1277.           proto = $1 " " $5;
  1278.     }
  1279. END    { if (proto == "")
  1280.           proto = "config.class1"
  1281.       print "ProtoType=" proto
  1282.     }
  1283.     ' C="$RESPONSE" -`
  1284.     echo "Modem manufacturer is \"$Manufacturer\"."
  1285.     echo "Modem model is \"$Model\"."
  1286. }
  1287.  
  1288. configureClass1and2Modem()
  1289. {
  1290.     echo "This modem looks to have support for both Class 1 and 2;"
  1291.     prompt "how should it be configured [2]?"
  1292.     x=""
  1293.     while [ "$x" != "1" -a "$x" != "2" ]; do
  1294.     read x
  1295.     case "$x" in
  1296.     1|2)    ;;
  1297.     ?*)    echo ""
  1298.             prompt "Configure as Class 1 or 2 [2]?";;
  1299.     *)    x="2";;
  1300.     esac
  1301.     done
  1302.     echo ""
  1303.     case $x in
  1304.     1) configureClass1Modem;;
  1305.     2) configureClass2Modem;;
  1306.     esac
  1307. }
  1308.  
  1309. configureClass1and2dot0Modem()
  1310. {
  1311.     echo "This modem looks to have support for both Class 1 and 2.0;"
  1312.     prompt "how should it be configured [2.0]?"
  1313.     x=""
  1314.     while [ "$x" != "1" -a "$x" != "2.0" ]; do
  1315.     read x
  1316.     case "$x" in
  1317.     1|2.0)    ;;
  1318.     ?*)    echo ""
  1319.             prompt "Configure as Class 1 or 2.0 [2.0]?";;
  1320.     *)    x="2.0";;
  1321.     esac
  1322.     done
  1323.     echo ""
  1324.     case $x in
  1325.     1)   configureClass1Modem;;
  1326.     2.0) configureClass2dot0Modem;;
  1327.     esac
  1328. }
  1329.  
  1330. configureClass2and2dot0Modem()
  1331. {
  1332.     echo "This modem looks to have support for both Class 2 and 2.0;"
  1333.     prompt "how should it be configured [2.0]?"
  1334.     x=""
  1335.     while [ "$x" != "2" -a "$x" != "2.0" ]; do
  1336.     read x
  1337.     case "$x" in
  1338.     2|2.0)    ;;
  1339.     ?*)    echo ""
  1340.             prompt "Configure as Class 2 or 2.0 [2.0]?";;
  1341.     *)    x="2.0";;
  1342.     esac
  1343.     done
  1344.     echo ""
  1345.     case $x in
  1346.     2)   configureClass2Modem;;
  1347.     2.0) configureClass2dot0Modem;;
  1348.     esac
  1349. }
  1350.  
  1351. configureClass1and2and2dot0Modem()
  1352. {
  1353.     echo "This modem looks to have support for both Class 1, 2 and 2.0;"
  1354.     prompt "how should it be configured [2.0]?"
  1355.     x=""
  1356.     while [ "$x" != "1" -a "$x" != "2" -a "$x" != "2.0" ]; do
  1357.     read x
  1358.     case "$x" in
  1359.     1|2|2.0)    ;;
  1360.     ?*)    echo ""
  1361.             prompt "Configure as Class 1, 2 or 2.0 [2.0]?";;
  1362.     *)    x="2.0";;
  1363.     esac
  1364.     done
  1365.     echo ""
  1366.     case $x in
  1367.     1)   configureClass1Modem;;
  1368.     2)   configureClass2Modem;;
  1369.     2.0) configureClass2dot0Modem;;
  1370.     esac
  1371. }
  1372.  
  1373. giveup()
  1374. {
  1375.     cat<<EOF
  1376.  
  1377. We were unable to deduce what type of modem you have.  This means that
  1378. it did not respond as a Class 1, Class 2, or Class 2.0 modem should and
  1379. it did not appear as though it was an Abaton 24/96 (as made by Everex).
  1380. If you believe that your modem conforms to the Class 1, Class 2, or
  1381. Class 2.0 interface specification, or is an Abaton modem, then check
  1382. that the modem is operating properly and that you can communicate with
  1383. the modem from the host.  If your modem is not one of the above types
  1384. of modems, then this software does not support it and you will need to
  1385. write a driver that supports it.
  1386.  
  1387. EOF
  1388.     exit 1
  1389. }
  1390.  
  1391. echo ""
  1392. if [ "$RESULT" = "OK" ]; then
  1393.     # Looks like a Class 1, 2, or 2.0 modem, get more information
  1394.     case "`echo $RESPONSE | sed -e 's/[()]//g'`" in
  1395.     1)            configureClass1Modem;;
  1396.     2)            configureClass2Modem;;
  1397.     2.0)        configureClass2dot0Modem;;
  1398.     0,1)        configureClass1Modem;;
  1399.     0,2)        configureClass2Modem;;
  1400.     0,2.0)        configureClass2dot0Modem;;
  1401.     1,2)        configureClass1and2Modem;;
  1402.     1,2.0)        configureClass1and2dot0Modem;;
  1403.     2,2.0)        configureClass2and2dot0Modem;;
  1404.     0,1,2)        configureClass1and2Modem;;
  1405.     0,1,2.0)        configureClass1and2dot0Modem;;
  1406.     0,2,2.0)        configureClass2and2dot0Modem;;
  1407.     1,2,2.0)        configureClass1and2and2dot0Modem;;
  1408.     0,1,2,2.0)        configureClass1and2and2dot0Modem;;
  1409.     0,1,2,2.0,*)    configureClass1and2and2dot0Modem;;
  1410.     1,2,2.0,*)        configureClass1and2and2dot0Modem;;
  1411.     0,2,2.0,*)        configureClass2and2dot0Modem;;
  1412.     0,1,2.0,*)        configureClass1and2dot0Modem;;
  1413.     0,1,2,*)        configureClass1and2Modem;;
  1414.     2,2.0,*)        configureClass2and2dot0Modem;;
  1415.     1,2.0,*)        configureClass1and2dot0Modem;;
  1416.     1,2,*)        configureClass1and2Modem;;
  1417.     0,2.0,*)        configureClass2dot0Modem;;
  1418.     0,2,*)        configureClass2Modem;;
  1419.     0,1,*)        configureClass1Modem;;
  1420.     2.0,*)        configureClass2dot0Modem;;
  1421.     2,*)        configureClass2Modem;;
  1422.     1,*)        configureClass1Modem;;
  1423.     *)
  1424.     echo "The result of the AT+FCLASS=? command was:"
  1425.     echo ""
  1426.     cat $OUT
  1427.     giveup
  1428.     ;;
  1429.     esac
  1430. else
  1431.     echo "This not a Class 1, 2, or 2.0 modem,"
  1432.     echo "lets check some other possibilities..."
  1433.  
  1434.     SendToModem "ATI4?"
  1435.     RESULT=`tr -d "\015" < $OUT | tail -1`
  1436.     echo ""
  1437.     if [ "$RESULT" != "OK" ]; then
  1438.     echo "The modem does not seem to understand the ATI4? query."
  1439.     echo "Sorry, but I can't figure out how to configure this one."
  1440.     exit 1
  1441.     fi
  1442.     case "$RESPONSE" in
  1443.     EV968*|EV958*)
  1444.     ModemType="Abaton";
  1445.     echo "Hmm, this looks like an Abaton 24/96 (specifically a $RESPONSE)."
  1446.     ;;
  1447.     *)    echo "The result of the ATI4? query was:"
  1448.     echo ""
  1449.     cat $OUT
  1450.     giveup;
  1451.     ;;
  1452.     esac
  1453. fi
  1454.  
  1455. echo ""
  1456. #
  1457. # Given a modem type, manufacturer and model, select
  1458. # a prototype configuration file to work from.
  1459. #
  1460. case $ModemType in
  1461. Class1|Class2*)
  1462.     echo "Using prototype configuration file $ProtoType..."
  1463.     ;;
  1464. Abaton)
  1465.     echo "Using prototype Abaton 24/96 configuration file..."
  1466.     ProtoType=config.abaton
  1467.     ;;
  1468. esac
  1469.  
  1470. proto=$MODEMCONFIG/$ProtoType
  1471. if [ ! -f $proto ]; then
  1472.    cat<<EOF
  1473. Uh oh, I can't find the prototype file
  1474.  
  1475. "$proto"
  1476.  
  1477. EOF
  1478.     if [ "$ProtoType" != "config.skel" ]; then
  1479.         prompt "Do you want to continue using the skeletal configuration file [yes]?"
  1480.         read x
  1481.         if [ "$x" = "n" -o "$x" = "no" ]; then
  1482.        exit 1
  1483.     fi
  1484.     ProtoType="config.skel";
  1485.     proto=$MODEMCONFIG/$ProtoType;
  1486.     if [ ! -f $proto ]; then
  1487.         cat<<EOF
  1488. Sigh, the skeletal configuration file is not available either.  There
  1489. is not anything that I can do without some kind of prototype config
  1490. file; I'm bailing out..."
  1491. EOF
  1492.         exit 1
  1493.     fi
  1494.     else
  1495.     echo "There is nothing more that I can do; I'm bailing out..."
  1496.     exit 1
  1497.     fi
  1498. fi
  1499.  
  1500. #
  1501. # Prompt the user for an AT-style command.
  1502. #
  1503. promptForATCmdParameter()
  1504. {
  1505.     prompt "$2 [$1]?"; read x
  1506.     if [ "$x" ]; then
  1507.     # strip leading and trailing white space,
  1508.     # quote marks, and any prefacing AT; redouble
  1509.     # any backslashes lost through shell processing
  1510.     x=`echo "$x" | \
  1511.         sed -e 's/^[     ]*//' -e 's/[     ]*$//' -e 's/\"//g' | \
  1512.         sed -e 's/^[aA][tT]//' -e 's/\\\\/&&/g'`
  1513.     else
  1514.     x="$1"
  1515.     fi
  1516.     param="$x"
  1517. }
  1518.  
  1519. #
  1520. # Prompt the user for a boolean value.
  1521. #
  1522. promptForBooleanParameter()
  1523. {
  1524.     x=""
  1525.     while [ -z "$x" ]; do
  1526.     prompt "$2 [$1]?"; read x
  1527.     if [ "$x" ]; then
  1528.         # strip leading and trailing white space
  1529.         x=`echo "$x" | sed -e 's/^[     ]*//' -e 's/[     ]*$//'`
  1530.         case "$x" in
  1531.         n|no|off)    x="no";;
  1532.         y|yes|on)    x="yes";;
  1533.         *)
  1534. cat <<EOF
  1535.  
  1536. "$x" is not a valid boolean parameter setting;
  1537. use one of: "yes", "on", "no", or "off".
  1538. EOF
  1539.         x="";;
  1540.         esac
  1541.     else
  1542.         x="$1"
  1543.     fi
  1544.     done
  1545.     param="$x"
  1546. }
  1547.  
  1548. #
  1549. # Prompt the user for a bit order.
  1550. #
  1551. promptForBitOrderParameter()
  1552. {
  1553.     x=""
  1554.     while [ -z "$x" ]; do
  1555.     prompt "$2 [$1]?"; read x
  1556.     if [ "$x" ]; then
  1557.         # strip leading and trailing white space
  1558.         x=`echo "$x" | sed -e 's/^[     ]*//' -e 's/[     ]*$//'`
  1559.         case "$x" in
  1560.         [lL]*)    x="LSB2MSB";;
  1561.         [mM]*)    x="MSB2LSB";;
  1562.         *)
  1563. cat <<EOF
  1564.  
  1565. "$x" is not a valid bit order parameter setting; use
  1566. one of: "lsb2msb", "LSB2MSB", "msb2lsb", or "MSB2LSB".
  1567. EOF
  1568.         x="";;
  1569.         esac
  1570.     else
  1571.         x="$1"
  1572.     fi
  1573.     done
  1574.     param="$x"
  1575. }
  1576.  
  1577. #
  1578. # Prompt the user for a flow control scheme.
  1579. #
  1580. promptForFlowControlParameter()
  1581. {
  1582.     x=""
  1583.     while [ -z "$x" ]; do
  1584.     prompt "$2 [$1]?"; read x
  1585.     if [ "$x" ]; then
  1586.         # strip leading and trailing white space
  1587.         x=`echo "$x" | sed -e 's/^[     ]*//' -e 's/[     ]*$//'`
  1588.         case "$x" in
  1589.         xon*|XON*)    x="xonxoff";;
  1590.         rts*|RTS*)    x="rtscts";;
  1591.         *)
  1592. cat <<EOF
  1593.  
  1594. "$x" is not a valid bit order parameter setting; use
  1595. one of: "xonxoff", "XONXOFF", "rtscts", or "RTSCTS".
  1596. EOF
  1597.         x="";;
  1598.         esac
  1599.     else
  1600.         x="$1"
  1601.     fi
  1602.     done
  1603.     param="$x"
  1604. }
  1605.  
  1606. saveModemProtoParameters()
  1607. {
  1608.     protoModemAnswerAnyCmd="$ModemAnswerAnyCmd"
  1609.     protoModemAnswerBeginDataCmd="$ModemAnswerBeginDataCmd"
  1610.     protoModemAnswerBeginFaxCmd="$ModemAnswerBeginFaxCmd"
  1611.     protoModemAnswerBeginVoiceCmd="$ModemAnswerBeginVoiceCmd"
  1612.     protoModemAnswerCmd="$ModemAnswerCmd"
  1613.     protoModemAnswerDataCmd="$ModemAnswerDataCmd"
  1614.     protoModemAnswerFaxCmd="$ModemAnswerFaxCmd"
  1615.     protoModemAnswerResponseTimeout="$ModemAnswerResponseTimeout"
  1616.     protoModemAnswerVoiceCmd="$ModemAnswerVoiceCmd"
  1617.     protoModemBaudRateDelay="$ModemBaudRateDelay"
  1618.     protoModemCommaPauseTimeCmd="$ModemCommaPauseTimeCmd"
  1619.     protoModemDialCmd="$ModemDialCmd"
  1620.     protoModemDialResponseTimeout="$ModemDialResponseTimeout"
  1621.     protoModemEchoOffCmd="$ModemEchoOffCmd"
  1622.     protoModemFlowControl="$ModemFlowControl"
  1623.     protoModemFlowControlCmd="$ModemFlowControlCmd"
  1624.     protoModemFrameFillOrder="$ModemFrameFillOrder"
  1625.     protoModemHostFillOrder="$ModemHostFillOrder"
  1626.     protoModemInterPacketDelay="$ModemInterPacketDelay"
  1627.     protoModemMaxPacketSize="$ModemMaxPacketSize"
  1628.     protoModemMfrQueryCmd="$ModemMfrQueryCmd"
  1629.     protoModemModelQueryCmd="$ModemModelQueryCmd"
  1630.     protoModemNoAutoAnswerCmd="$ModemNoAutoAnswerCmd"
  1631.     protoModemOnHookCmd="$ModemOnHookCmd"
  1632.     protoModemPageDoneTimeout="$ModemPageDoneTimeout"
  1633.     protoModemPageStartTimeout="$ModemPageStartTimeout"
  1634.     protoModemRate="$ModemRate"
  1635.     protoModemRecvFillOrder="$ModemRecvFillOrder"
  1636.     protoModemResetCmds="$ModemResetCmds"
  1637.     protoModemResetDelay="$ModemResetDelay"
  1638.     protoModemResultCodesCmd="$ModemResultCodesCmd"
  1639.     protoModemRevQueryCmd="$ModemRevQueryCmd"
  1640.     protoModemSendFillOrder="$ModemSendFillOrder"
  1641.     protoModemSetVolumeCmd="$ModemSetVolumeCmd"
  1642.     protoModemSetupAACmd="$ModemSetupAACmd"
  1643.     protoModemSetupDCDCmd="$ModemSetupDCDCmd"
  1644.     protoModemSetupDTRCmd="$ModemSetupDTRCmd"
  1645.     protoModemSoftResetCmd="$ModemSoftResetCmd"
  1646.     protoModemVerboseResultsCmd="$ModemVerboseResultsCmd"
  1647.     protoModemWaitForConnect="$ModemWaitForConnect"
  1648.     protoModemWaitTimeCmd="$ModemWaitTimeCmd"
  1649.  
  1650.     protoFaxT1Timer="$FaxT1Timer"
  1651.     protoFaxT2Timer="$FaxT2Timer"
  1652.     protoFaxT4Timer="$FaxT4Timer"
  1653.     case "$ModemType" in
  1654.     Class1*)
  1655.     protoClass1Cmd="$Class1Cmd"
  1656.     protoClass1FrameOverhead="$Class1FrameOverhead"
  1657.     protoClass1RecvAbortOK="$Class1RecvAbortOK"
  1658.     protoClass1RecvIdentTimer="$Class1RecvIdentTimer"
  1659.     protoClass1SendPPMDelay="$Class1SendPPMDelay"
  1660.     protoClass1SendTCFDelay="$Class1SendTCFDelay"
  1661.     protoClass1TCFResponseDelay="$Class1TCFResponseDelay"
  1662.     protoClass1TrainingRecovery="$Class1TrainingRecovery"
  1663.     ;;
  1664.     Class2*)
  1665.     protoClass2AbortCmd="$Class2AbortCmd"
  1666.     protoClass2BORCmd="$Class2BORCmd"
  1667.     protoClass2BUGCmd="$Class2BUGCmd"
  1668.     protoClass2CIGCmd="$Class2CIGCmd"
  1669.     protoClass2CQCmd="$Class2CQCmd"
  1670.     protoClass2CRCmd="$Class2CRCmd"
  1671.     protoClass2Cmd="$Class2Cmd"
  1672.     protoClass2DCCCmd="$Class2DCCCmd"
  1673.     protoClass2DCCQueryCmd="$Class2DCCQueryCmd"
  1674.     protoClass2DISCmd="$Class2DISCmd"
  1675.     protoClass2LIDCmd="$Class2LIDCmd"
  1676.     protoClass2NRCmd="$Class2NRCmd"
  1677.     protoClass2PHCTOCmd="$Class2PHCTOCmd"
  1678.     protoClass2PIECmd="$Class2PIECmd"
  1679.     protoClass2RELCmd="$Class2RELCmd"
  1680.     protoClass2RecvDataTrigger="$Class2RecvDataTrigger"
  1681.     protoClass2SPLCmd="$Class2SPLCmd"
  1682.     protoClass2TBCCmd="$Class2TBCCmd"
  1683.     protoClass2XmitWaitForXON="$Class2XmitWaitForXON"
  1684.     ;;
  1685.     esac
  1686. }
  1687.  
  1688. #
  1689. # Get the default modem parameter values
  1690. # from the prototype configuration file.
  1691. #
  1692. getModemProtoParameters()
  1693. {
  1694.     getParameter ModemAnswerAnyCmd $1;        ModemAnswerAnyCmd="$param"
  1695.     getParameter ModemAnswerBeginDataCmd $1;    ModemAnswerBeginDataCmd="$param"
  1696.     getParameter ModemAnswerBeginFaxCmd $1;    ModemAnswerBeginFaxCmd="$param"
  1697.     getParameter ModemAnswerBeginVoiceCmd $1;    ModemAnswerBeginVoiceCmd="$param"
  1698.     getParameter ModemAnswerCmd $1;        ModemAnswerCmd="$param"
  1699.     getParameter ModemAnswerDataCmd $1;        ModemAnswerDataCmd="$param"
  1700.     getParameter ModemAnswerFaxCmd $1;        ModemAnswerFaxCmd="$param"
  1701.     getParameter ModemAnswerResponseTimeout $1;    ModemAnswerResponseTimeout="$param"
  1702.     getParameter ModemAnswerVoiceCmd $1;    ModemAnswerVoiceCmd="$param"
  1703.     getParameter ModemBaudRateDelay $1;        ModemBaudRateDelay="$param"
  1704.     getParameter ModemCommaPauseTimeCmd $1;    ModemCommaPauseTimeCmd="$param"
  1705.     getParameter ModemDialCmd $1;        ModemDialCmd="$param"
  1706.     getParameter ModemDialResponseTimeout $1;    ModemDialResponseTimeout="$param"
  1707.     getParameter ModemEchoOffCmd $1;        ModemEchoOffCmd="$param"
  1708.     getParameter ModemFlowControl $1;        ModemFlowControl="$param"
  1709.     getParameter ModemFlowControlCmd $1;    ModemFlowControlCmd="$param"
  1710.     getParameter ModemFrameFillOrder $1;    ModemFrameFillOrder="$param"
  1711.     getParameter ModemHostFillOrder $1;        ModemHostFillOrder="$param"
  1712.     getParameter ModemInterPacketDelay $1;    ModemInterPacketDelay="$param"
  1713.     getParameter ModemMaxPacketSize $1;        ModemMaxPacketSize="$param"
  1714.     getParameter ModemMfrQueryCmd $1;        ModemMfrQueryCmd="$param"
  1715.     getParameter ModemModelQueryCmd $1;        ModemModelQueryCmd="$param"
  1716.     getParameter ModemNoAutoAnswerCmd $1;    ModemNoAutoAnswerCmd="$param"
  1717.     getParameter ModemOnHookCmd $1;        ModemOnHookCmd="$param"
  1718.     getParameter ModemPageDoneTimeout $1;    ModemPageDoneTimeout="$param"
  1719.     getParameter ModemPageStartTimeout $1;    ModemPageStartTimeout="$param"
  1720.     getParameter ModemRate $1;            ModemRate="$param"
  1721.     getParameter ModemRecvFillOrder $1;        ModemRecvFillOrder="$param"
  1722.     getParameter ModemResetCmds $1;        ModemResetCmds="$param"
  1723.     getParameter ModemResetDelay $1;        ModemResetDelay="$param"
  1724.     getParameter ModemResultCodesCmd $1;    ModemResultCodesCmd="$param"
  1725.     getParameter ModemRevQueryCmd $1;        ModemRevQueryCmd="$param"
  1726.     getParameter ModemSendFillOrder $1;        ModemSendFillOrder="$param"
  1727.     getParameter ModemSetVolumeCmd $1;        ModemSetVolumeCmd="$param"
  1728.     getParameter ModemSetupAACmd $1;        ModemSetupAACmd="$param"
  1729.     getParameter ModemSetupDCDCmd $1;        ModemSetupDCDCmd="$param"
  1730.     getParameter ModemSetupDTRCmd $1;        ModemSetupDTRCmd="$param"
  1731.     getParameter ModemSoftResetCmd $1;        ModemSoftResetCmd="$param"
  1732.     getParameter ModemVerboseResultsCmd $1;    ModemVerboseResultsCmd="$param"
  1733.     getParameter ModemWaitForConnect $1;    ModemWaitForConnect="$param"
  1734.     getParameter ModemWaitTimeCmd $1;        ModemWaitTimeCmd="$param"
  1735.  
  1736.     getParameter FaxT1Timer $1;            FaxT1Timer="$param"
  1737.     getParameter FaxT2Timer $1;            FaxT2Timer="$param"
  1738.     getParameter FaxT4Timer $1;            FaxT4Timer="$param"
  1739.     case "$ModemType" in
  1740.     Class1*)
  1741.     getParameter Class1Cmd $1;        Class1Cmd="$param"
  1742.     getParameter Class1FrameOverhead $1;    Class1FrameOverhead="$param"
  1743.     getParameter Class1RecvAbortOK $1;    Class1RecvAbortOK="$param"
  1744.     getParameter Class1RecvIdentTimer $1;    Class1RecvIdentTimer="$param"
  1745.     getParameter Class1SendPPMDelay $1;    Class1SendPPMDelay="$param"
  1746.     getParameter Class1SendTCFDelay $1;    Class1SendTCFDelay="$param"
  1747.     getParameter Class1TCFResponseDelay $1;    Class1TCFResponseDelay="$param"
  1748.     getParameter Class1TrainingRecovery $1;    Class1TrainingRecovery="$param"
  1749.     ;;
  1750.     Class2*)
  1751.     getParameter Class2AbortCmd $1;        Class2AbortCmd="$param"
  1752.     getParameter Class2BORCmd $1;        Class2BORCmd="$param"
  1753.     getParameter Class2BUGCmd $1;        Class2BUGCmd="$param"
  1754.     getParameter Class2CIGCmd $1;        Class2CIGCmd="$param"
  1755.     getParameter Class2CQCmd $1;        Class2CQCmd="$param"
  1756.     getParameter Class2CRCmd $1;        Class2CRCmd="$param"
  1757.     getParameter Class2Cmd $1;        Class2Cmd="$param"
  1758.     getParameter Class2DCCCmd $1;        Class2DCCCmd="$param"
  1759.     getParameter Class2DCCQueryCmd $1;    Class2DCCQueryCmd="$param"
  1760.     getParameter Class2DISCmd $1;        Class2DISCmd="$param"
  1761.     getParameter Class2LIDCmd $1;        Class2LIDCmd="$param"
  1762.     getParameter Class2NRCmd $1;        Class2NRCmd="$param"
  1763.     getParameter Class2PHCTOCmd $1;        Class2PHCTOCmd="$param"
  1764.     getParameter Class2PIECmd $1;        Class2PIECmd="$param"
  1765.     getParameter Class2RELCmd $1;        Class2RELCmd="$param"
  1766.     getParameter Class2RecvDataTrigger $1;    Class2RecvDataTrigger="$param"
  1767.     getParameter Class2SPLCmd $1;        Class2SPLCmd="$param"
  1768.     getParameter Class2TBCCmd $1;        Class2TBCCmd="$param"
  1769.     getParameter Class2XmitWaitForXON $1;    Class2XmitWaitForXON="$param"
  1770.     ;;
  1771.     esac
  1772.  
  1773.     #
  1774.     # If a dialing prefix was being used, add it to the
  1775.     # dialing command string.  Perhaps this is too simplistic.
  1776.     #
  1777.     if [ "$DialingPrefix" ]; then
  1778.     ModemDialCmd="${DialingPrefix}${ModemDialCmd}"
  1779.     fi
  1780.     saveModemProtoParameters
  1781. }
  1782.  
  1783. addSedCmd()
  1784. {
  1785.     test "$1" != "$2" && {
  1786.     # escape backslashes to counteract shell parsing and sed magic chars
  1787.     x=`echo "$2" | sed 's/[&\\\\"]/\\\\&/g'`
  1788.     if [ `expr "$2" : "[^\"].*[ ]"` = 0 ]; then
  1789.         ModemCmds="$ModemCmds -e '/^$3:/s;\(:[     ]*\).*;\1$x;'"
  1790.     else
  1791.         ModemCmds="$ModemCmds -e '/^$3:/s;\(:[     ]*\).*;\1\"$x\";'"
  1792.     fi
  1793.     }
  1794. }
  1795.  
  1796. #
  1797. # Setup the sed commands for crafting the configuration file:
  1798. #
  1799. makeSedModemCommands()
  1800. {
  1801.     ModemCmds=""
  1802.  
  1803.     addSedCmd "$protoModemAnswerAnyCmd" \
  1804.     "$ModemAnswerAnyCmd"            ModemAnswerAnyCmd
  1805.     addSedCmd "$protoModemAnswerBeginDataCmd" \
  1806.     "$ModemAnswerBeginDataCmd"        ModemAnswerBeginDataCmd
  1807.     addSedCmd "$protoModemAnswerBeginFaxCmd" \
  1808.     "$ModemAnswerBeginFaxCmd"        ModemAnswerBeginFaxCmd
  1809.     addSedCmd "$protoModemAnswerBeginVoiceCmd" \
  1810.     "$ModemAnswerBeginVoiceCmd"        ModemAnswerBeginVoiceCmd
  1811.     addSedCmd "$protoModemAnswerCmd" \
  1812.     "$ModemAnswerCmd"            ModemAnswerCmd
  1813.     addSedCmd "$protoModemAnswerDataCmd" \
  1814.     "$ModemAnswerDataCmd"            ModemAnswerDataCmd
  1815.     addSedCmd "$protoModemAnswerFaxCmd" \
  1816.     "$ModemAnswerFaxCmd"            ModemAnswerFaxCmd
  1817.     addSedCmd "$protoModemAnswerResponseTimeout" \
  1818.     "$ModemAnswerResponseTimeout"        ModemAnswerResponseTimeout
  1819.     addSedCmd "$protoModemAnswerVoiceCmd" \
  1820.     "$ModemAnswerVoiceCmd"            ModemAnswerVoiceCmd
  1821.     addSedCmd "$protoModemBaudRateDelay" \
  1822.     "$ModemBaudRateDelay"            ModemBaudRateDelay
  1823.     addSedCmd "$protoModemCommaPauseTimeCmd" \
  1824.     "$ModemCommaPauseTimeCmd"        ModemCommaPauseTimeCmd
  1825.     addSedCmd "$protoModemDialCmd" \
  1826.     "$ModemDialCmd"                ModemDialCmd
  1827.     addSedCmd "$protoModemDialResponseTimeout" \
  1828.     "$ModemDialResponseTimeout"        ModemDialResponseTimeout
  1829.     addSedCmd "$protoModemEchoOffCmd" \
  1830.     "$ModemEchoOffCmd"            ModemEchoOffCmd
  1831.     addSedCmd "$protoModemFlowControl" \
  1832.     "$ModemFlowControl"            ModemFlowControl
  1833.     addSedCmd "$protoModemFlowControlCmd" \
  1834.     "$ModemFlowControlCmd"            ModemFlowControlCmd
  1835.     addSedCmd "$protoModemFrameFillOrder" \
  1836.     "$ModemFrameFillOrder"            ModemFrameFillOrder
  1837.     addSedCmd "$protoModemHostFillOrder" \
  1838.     "$ModemHostFillOrder"            ModemHostFillOrder
  1839.     addSedCmd "$protoModemInterPacketDelay" \
  1840.     "$ModemInterPacketDelay"        ModemInterPacketDelay
  1841.     addSedCmd "$protoModemMaxPacketSize" \
  1842.     "$ModemMaxPacketSize"            ModemMaxPacketSize
  1843.     addSedCmd "$protoModemMfrQueryCmd" \
  1844.     "$ModemMfrQueryCmd"            ModemMfrQueryCmd
  1845.     addSedCmd "$protoModemModelQueryCmd" \
  1846.     "$ModemModelQueryCmd"            ModemModelQueryCmd
  1847.     addSedCmd "$protoModemNoAutoAnswerCmd" \
  1848.     "$ModemNoAutoAnswerCmd"            ModemNoAutoAnswerCmd
  1849.     addSedCmd "$protoModemOnHookCmd" \
  1850.     "$ModemOnHookCmd"            ModemOnHookCmd
  1851.     addSedCmd "$protoModemPageDoneTimeout" \
  1852.     "$ModemPageDoneTimeout"            ModemPageDoneTimeout
  1853.     addSedCmd "$protoModemPageStartTimeout" \
  1854.     "$ModemPageStartTimeout"        ModemPageStartTimeout
  1855.     addSedCmd "$protoModemRate" \
  1856.     "$ModemRate"                ModemRate
  1857.     addSedCmd "$protoModemRecvFillOrder" \
  1858.     "$ModemRecvFillOrder"            ModemRecvFillOrder
  1859.     addSedCmd "$protoModemResetCmds" \
  1860.     "$ModemResetCmds"            ModemResetCmds
  1861.     addSedCmd "$protoModemResetDelay" \
  1862.     "$ModemResetDelay"            ModemResetDelay
  1863.     addSedCmd "$protoModemResultCodesCmd" \
  1864.     "$ModemResultCodesCmd"            ModemResultCodesCmd
  1865.     addSedCmd "$protoModemRevQueryCmd" \
  1866.     "$ModemRevQueryCmd"            ModemRevQueryCmd
  1867.     addSedCmd "$protoModemSendFillOrder" \
  1868.     "$ModemSendFillOrder"            ModemSendFillOrder
  1869.     addSedCmd "$protoModemSetVolumeCmd" \
  1870.     "$ModemSetVolumeCmd"            ModemSetVolumeCmd
  1871.     addSedCmd "$protoModemSetupAACmd" \
  1872.     "$ModemSetupAACmd"            ModemSetupAACmd
  1873.     addSedCmd "$protoModemSetupDCDCmd" \
  1874.     "$ModemSetupDCDCmd"            ModemSetupDCDCmd
  1875.     addSedCmd "$protoModemSetupDTRCmd" \
  1876.     "$ModemSetupDTRCmd"            ModemSetupDTRCmd
  1877.     addSedCmd "$protoModemSoftResetCmd" \
  1878.     "$ModemSoftResetCmd"            ModemSoftResetCmd
  1879.     addSedCmd "$protoModemVerboseResultsCmd" \
  1880.     "$ModemVerboseResultsCmd"        ModemVerboseResultsCmd
  1881.     addSedCmd "$protoModemWaitForConnect" \
  1882.     "$ModemWaitForConnect"            ModemWaitForConnect
  1883.     addSedCmd "$protoModemWaitTimeCmd" \
  1884.     "$ModemWaitTimeCmd"            ModemWaitTimeCmd
  1885.  
  1886.     addSedCmd "$protoFaxT1Timer" "$FaxT1Timer"    FaxT1Timer
  1887.     addSedCmd "$protoFaxT2Timer" "$FaxT2Timer"    FaxT2Timer
  1888.     addSedCmd "$protoFaxT4Timer" "$FaxT4Timer"    FaxT4Timer
  1889.     case "$ModemType" in
  1890.     Class1*)
  1891.     addSedCmd "$protoClass1Cmd" "$Class1Cmd" Class1Cmd
  1892.     addSedCmd "$protoClass1FrameOverhead" \
  1893.         "$Class1FrameOverhead"        Class1FrameOverhead
  1894.     addSedCmd "$protoClass1RecvAbortOK" \
  1895.         "$Class1RecvAbortOK"        Class1RecvAbortOK
  1896.     addSedCmd "$protoClass1RecvIdentTimer" \
  1897.         "$Class1RecvIdentTimer"        Class1RecvIdentTimer
  1898.     addSedCmd "$protoClass1SendPPMDelay" \
  1899.         "$Class1SendPPMDelay"        Class1SendPPMDelay
  1900.     addSedCmd "$protoClass1SendTCFDelay" \
  1901.         "$Class1SendTCFDelay"        Class1SendTCFDelay
  1902.     addSedCmd "$protoClass1TCFResponseDelay" \
  1903.         "$Class1TCFResponseDelay"        Class1TCFResponseDelay
  1904.     addSedCmd "$protoClass1TrainingRecovery" \
  1905.         "$Class1TrainingRecovery"        Class1TrainingRecovery
  1906.     ;;
  1907.     Class2*)
  1908.     addSedCmd "$protoClass2AbortCmd" \
  1909.         "$Class2AbortCmd"            Class2AbortCmd
  1910.     addSedCmd "$protoClass2BORCmd" \
  1911.         "$Class2BORCmd"            Class2BORCmd
  1912.     addSedCmd "$protoClass2BUGCmd" \
  1913.         "$Class2BUGCmd"            Class2BUGCmd
  1914.     addSedCmd "$protoClass2CIGCmd" \
  1915.         "$Class2CIGCmd"            Class2CIGCmd
  1916.     addSedCmd "$protoClass2CQCmd" \
  1917.         "$Class2CQCmd"            Class2CQCmd
  1918.     addSedCmd "$protoClass2CRCmd" \
  1919.         "$Class2CRCmd"            Class2CRCmd
  1920.     addSedCmd "$protoClass2Cmd" \
  1921.         "$Class2Cmd"            Class2Cmd
  1922.     addSedCmd "$protoClass2DCCCmd" \
  1923.         "$Class2DCCCmd"            Class2DCCCmd
  1924.     addSedCmd "$protoClass2DCCQueryCmd" \
  1925.         "$Class2DCCQueryCmd"        Class2DCCQueryCmd
  1926.     addSedCmd "$protoClass2DISCmd" \
  1927.         "$Class2DISCmd"            Class2DISCmd
  1928.     addSedCmd "$protoClass2LIDCmd" \
  1929.         "$Class2LIDCmd"            Class2LIDCmd
  1930.     addSedCmd "$protoClass2NRCmd" \
  1931.         "$Class2NRCmd"            Class2NRCmd
  1932.     addSedCmd "$protoClass2PHCTOCmd" \
  1933.         "$Class2PHCTOCmd"            Class2PHCTOCmd
  1934.     addSedCmd "$protoClass2PIECmd" \
  1935.         "$Class2PIECmd"            Class2PIECmd
  1936.     addSedCmd "$protoClass2RELCmd" \
  1937.         "$Class2RELCmd"            Class2RELCmd
  1938.     addSedCmd "$protoClass2RecvDataTrigger" \
  1939.         "$Class2RecvDataTrigger"        Class2RecvDataTrigger
  1940.     addSedCmd "$protoClass2SPLCmd" \
  1941.         "$Class2SPLCmd"            Class2SPLCmd
  1942.     addSedCmd "$protoClass2TBCCmd" \
  1943.         "$Class2TBCCmd"            Class2TBCCmd
  1944.     addSedCmd "$protoClass2XmitWaitForXON" \
  1945.         "$Class2XmitWaitForXON"        Class2XmitWaitForXON
  1946.     ;;
  1947.     esac
  1948. }
  1949.  
  1950. #
  1951. # Check if the configured flow control scheme is
  1952. # consistent with the tty device being used.
  1953. #
  1954. checkFlowControlAgainstTTY()
  1955. {
  1956.     case "$ModemFlowControl" in
  1957.     xonxoff|XONXOFF)
  1958.     if [ "$TTY" = "ttyf${PORT}" -a -c /dev/ttym${PORT} ]; then
  1959.         echo ""
  1960.         echo "Warning, the modem is setup to use software flow control,"
  1961.         echo "but the \"$TTY\" device is used with hardware flow control"
  1962.         prompt "Do you want to use \"ttym${PORT}\" instead [yes]?"
  1963.         read x
  1964.         if [ -z "$x" -o "$x" = "y" -o "$x" = "yes" ]; then
  1965.         TTY="ttym${PORT}"
  1966.         DEVID="`echo $TTY | tr '/' '_'`"
  1967.         CONFIG=$CPATH.$DEVID
  1968.         fi
  1969.     fi
  1970.     ;;
  1971.     rtscts|RTSCTS)
  1972.     if [ "$TTY" = "ttym${PORT}" -a -c /dev/ttyf${PORT} ]; then
  1973.         echo ""
  1974.         echo "Warning, the modem is setup to use hardware flow control,"
  1975.         echo "but the \"$TTY\" device does not honor the RTS/CTS signals."
  1976.         prompt "Do you want to use \"ttyf${PORT}\" instead [yes]?"
  1977.         read x
  1978.         if [ -z "$x" -o "$x" = "y" -o "$x" = "yes" ]; then
  1979.         TTY="ttyf${PORT}"
  1980.         DEVID="`echo $TTY | tr '/' '_'`"
  1981.         CONFIG=$CPATH.$DEVID
  1982.         fi
  1983.     fi
  1984.     ;;
  1985.     esac
  1986. }
  1987.  
  1988. printIfNotNull()
  1989. {
  1990.     test "$2" && {
  1991.     x=`echo "$2" | sed 's/\\\\/&&/g'`    # escape backslashes to shell
  1992.     echo "$1    $x"
  1993.     }
  1994. }
  1995.  
  1996. #
  1997. # Print the current modem-related parameters.
  1998. #
  1999. printModemConfig()
  2000. {
  2001.     echo ""
  2002.     echo "The modem configuration parameters are:"
  2003.     echo ""
  2004.     printIfNotNull "ModemAnswerCmd:    "    "$ModemAnswerCmd"
  2005.     printIfNotNull "ModemAnswerAnyCmd:"        "$ModemAnswerAnyCmd"
  2006.     printIfNotNull "ModemAnswerDataCmd:"    "$ModemAnswerDataCmd"
  2007.     printIfNotNull "ModemAnswerFaxCmd:"        "$ModemAnswerFaxCmd"
  2008.     printIfNotNull "ModemAnswerVoiceCmd:"    "$ModemAnswerVoiceCmd"
  2009.     printIfNotNull "ModemAnswerBeginDataCmd:"    "$ModemAnswerBeginDataCmd"
  2010.     printIfNotNull "ModemAnswerBeginFaxCmd:"    "$ModemAnswerBeginFaxCmd"
  2011.     printIfNotNull "ModemAnswerBeginVoiceCmd:"    "$ModemAnswerBeginVoiceCmd"
  2012.     printIfNotNull "ModemAnswerResponseTimeout:" "$ModemAnswerResponseTimeout"
  2013.     printIfNotNull "ModemBaudRateDelay:"    "$ModemBaudRateDelay"
  2014.     printIfNotNull "ModemCommaPauseTimeCmd:"    "$ModemCommaPauseTimeCmd"
  2015.     printIfNotNull "ModemDialCmd:    "    "$ModemDialCmd"
  2016.     printIfNotNull "ModemDialResponseTimeout:"    "$ModemDialResponseTimeout"
  2017.     printIfNotNull "ModemEchoOffCmd:    "    "$ModemEchoOffCmd"
  2018.     printIfNotNull "ModemFlowControl:"        "$ModemFlowControl"
  2019.     printIfNotNull "ModemFlowControlCmd:"    "$ModemFlowControlCmd"
  2020.     printIfNotNull "ModemFrameFillOrder:"    "$ModemFrameFillOrder"
  2021.     printIfNotNull "ModemHostFillOrder:"    "$ModemHostFillOrder"
  2022.     printIfNotNull "ModemInterPacketDelay:"    "$ModemInterPacketDelay"
  2023.     printIfNotNull "ModemMaxPacketSize:"    "$ModemMaxPacketSize"
  2024.     printIfNotNull "ModemMfrQueryCmd:"        "$ModemMfrQueryCmd"
  2025.     printIfNotNull "ModemModelQueryCmd:"    "$ModemModelQueryCmd"
  2026.     printIfNotNull "ModemNoAutoAnswerCmd:"    "$ModemNoAutoAnswerCmd"
  2027.     printIfNotNull "ModemOnHookCmd:    "    "$ModemOnHookCmd"
  2028.     printIfNotNull "ModemPageDoneTimeout:"    "$ModemPageDoneTimeout"
  2029.     printIfNotNull "ModemPageStartTimeout:"    "$ModemPageStartTimeout"
  2030.     printIfNotNull "ModemRate:    "        "$ModemRate"
  2031.     printIfNotNull "ModemRecvFillOrder:"    "$ModemRecvFillOrder"
  2032.     printIfNotNull "ModemResetCmds:    "    "$ModemResetCmds"
  2033.     printIfNotNull "ModemResetDelay:"        "$ModemResetDelay"
  2034.     printIfNotNull "ModemResultCodesCmd:"    "$ModemResultCodesCmd"
  2035.     printIfNotNull "ModemRevQueryCmd:"        "$ModemRevQueryCmd"
  2036.     printIfNotNull "ModemSendFillOrder:"    "$ModemSendFillOrder"
  2037.     printIfNotNull "ModemSetVolumeCmd:"        "$ModemSetVolumeCmd"
  2038.     printIfNotNull "ModemSetupAACmd:"        "$ModemSetupAACmd"
  2039.     printIfNotNull "ModemSetupDCDCmd:"        "$ModemSetupDCDCmd"
  2040.     printIfNotNull "ModemSetupDTRCmd:"        "$ModemSetupDTRCmd"
  2041.     printIfNotNull "ModemSoftResetCmd:"        "$ModemSoftResetCmd"
  2042.     printIfNotNull "ModemVerboseResultsCmd:"    "$ModemVerboseResultsCmd"
  2043.     printIfNotNull "ModemWaitForConnect:"    "$ModemWaitForConnect"
  2044.     printIfNotNull "ModemWaitTimeCmd:"        "$ModemWaitTimeCmd"
  2045.  
  2046.     printIfNotNull "FaxT1Timer:    "        "$FaxT1Timer"
  2047.     printIfNotNull "FaxT2Timer:    "        "$FaxT2Timer"
  2048.     printIfNotNull "FaxT4Timer:    "        "$FaxT4Timer"
  2049.     case "$ModemType" in
  2050.     Class1*)
  2051.     printIfNotNull "Class1Cmd:    "    "$Class1Cmd"
  2052.     printIfNotNull "Class1FrameOverhead:"    "$Class1FrameOverhead"
  2053.     printIfNotNull "Class1RecvAbortOK:"    "$Class1RecvAbortOK"
  2054.     printIfNotNull "Class1RecvIdentTimer:"    "$Class1RecvIdentTimer"
  2055.     printIfNotNull "Class1SendPPMDelay:"    "$Class1SendPPMDelay"
  2056.     printIfNotNull "Class1SendTCFDelay:"    "$Class1SendTCFDelay"
  2057.     printIfNotNull "Class1TCFResponseDelay:" "$Class1TCFResponseDelay"
  2058.     printIfNotNull "Class1TrainingRecovery:" "$Class1TrainingRecovery"
  2059.     ;;
  2060.     Class2*)
  2061.     printIfNotNull "Class2AbortCmd:"    "$Class2AbortCmd"
  2062.     printIfNotNull "Class2BORCmd:    "    "$Class2BORCmd"
  2063.     printIfNotNull "Class2BUGCmd:    "    "$Class2BUGCmd"
  2064.     printIfNotNull "Class2CIGCmd:    "    "$Class2CIGCmd"
  2065.     printIfNotNull "Class2CQCmd:    "    "$Class2CQCmd"
  2066.     printIfNotNull "Class2CRCmd:    "    "$Class2CRCmd"
  2067.     printIfNotNull "Class2Cmd:    "    "$Class2Cmd"
  2068.     printIfNotNull "Class2DCCCmd:    "    "$Class2DCCCmd"
  2069.     printIfNotNull "Class2DCCQueryCmd:"    "$Class2DCCQueryCmd"
  2070.     printIfNotNull "Class2DISCmd:    "    "$Class2DISCmd"
  2071.     printIfNotNull "Class2LIDCmd:    "    "$Class2LIDCmd"
  2072.     printIfNotNull "Class2NRCmd:    "    "$Class2NRCmd"
  2073.     printIfNotNull "Class2PHCTOCmd:    "    "$Class2PHCTOCmd"
  2074.     printIfNotNull "Class2PIECmd:    "    "$Class2PIECmd"
  2075.     printIfNotNull "Class2RELCmd:    "    "$Class2RELCmd"
  2076.     printIfNotNull "Class2RecvDataTrigger:"    "$Class2RecvDataTrigger"
  2077.     printIfNotNull "Class2SPLCmd:    "    "$Class2SPLCmd"
  2078.     printIfNotNull "Class2TBCCmd:    "    "$Class2TBCCmd"
  2079.     printIfNotNull "Class2XmitWaitForXON:"    "$Class2XmitWaitForXON"
  2080.     ;;
  2081.     esac
  2082.     echo ""
  2083. }
  2084.  
  2085. #
  2086. # Prompt the user to edit the current parameters.  Note that
  2087. # we can only edit parameters that are in the prototype config
  2088. # file; thus all the checks to see if the prototype value exists.
  2089. #
  2090. promptForModemParameters()
  2091. {
  2092.     test "$protoModemAnswerCmd" && {
  2093.     promptForATCmdParameter "$ModemAnswerCmd" \
  2094.         "Command for answering the phone"
  2095.     ModemAnswerCmd="$param";
  2096.     }
  2097.     test "$protoModemAnswerAnyCmd" && {
  2098.     promptForATCmdParameter "$ModemAnswerAnyCmd" \
  2099.         "Command for answering any type of call"
  2100.     ModemAnswerAnyCmd="$param";
  2101.     }
  2102.     test "$protoModemAnswerDataCmd" && {
  2103.     promptForATCmdParameter "$ModemAnswerDataCmd" \
  2104.         "Command for answering a data call"
  2105.     ModemAnswerDataCmd="$param";
  2106.     }
  2107.     test "$protoModemAnswerFaxCmd" && {
  2108.     promptForATCmdParameter "$ModemAnswerFaxCmd" \
  2109.         "Command for answering a fax call"
  2110.     ModemAnswerFaxCmd="$param";
  2111.     }
  2112.     test "$protoModemAnswerVoiceCmd" && {
  2113.     promptForATCmdParameter "$ModemAnswerVoiceCmd" \
  2114.         "Command for answering a voice call"
  2115.     ModemAnswerVoiceCmd="$param";
  2116.     }
  2117.     test "$protoModemAnswerBeginDataCmd" && {
  2118.     promptForATCmdParameter "$ModemAnswerBeginDataCmd" \
  2119.         "Command for start of a data call"
  2120.     ModemAnswerBeginDataCmd="$param";
  2121.     }
  2122.     test "$protoModemAnswerBeginFaxCmd" && {
  2123.     promptForATCmdParameter "$ModemAnswerBeginFaxCmd" \
  2124.         "Command for start of a fax call"
  2125.     ModemAnswerBeginFaxCmd="$param";
  2126.     }
  2127.     test "$protoModemAnswerBeginVoiceCmd" && {
  2128.     promptForATCmdParameter "$ModemAnswerBeginVoiceCmd" \
  2129.         "Command for start of a voice call"
  2130.     ModemAnswerBeginVoiceCmd="$param";
  2131.     }
  2132.     test "$protoModemAnswerResponseTimeout" && {
  2133.     promptForNumericParameter "$ModemAnswerResponseTimeout" \
  2134.         "Answer command response timeout (ms)"
  2135.     ModemAnswerResponseTimeout="$param";
  2136.     }
  2137.     test "$protoModemBaudRateDelay" && {
  2138.     promptForNumericParameter "$ModemBaudRateDelay" \
  2139.         "Delay after setting tty baud rate (ms)"
  2140.     ModemBaudRateDelay="$param";
  2141.     }
  2142.     test "$protoModemCommaPauseTimeCmd" && {
  2143.     promptForATCmdParameter "$ModemCommaPauseTimeCmd" \
  2144.         "Command for setting time to pause for \",\" in dialing string"
  2145.     ModemCommaPauseTimeCmd="$param";
  2146.     }
  2147.     test "$protoModemDialCmd" && {
  2148.     promptForATCmdParameter "$ModemDialCmd" \
  2149.         "Command for dialing (%s for number to dial)"
  2150.     ModemDialCmd="$param";
  2151.     }
  2152.     test "$protoModemDialResponseTimeout" && {
  2153.     promptForNumericParameter "$ModemDialResponseTimeout" \
  2154.         "Dialing command response timeout (ms)"
  2155.     ModemDialResponseTimeout="$param";
  2156.     }
  2157.     test "$protoModemEchoOffCmd" && {
  2158.     promptForATCmdParameter "$ModemEchoOffCmd" \
  2159.         "Command for disabling command echo"
  2160.     ModemEchoOffCmd="$param";
  2161.     }
  2162.     test "$protoModemFlowControl" && {
  2163.     promptForFlowControlParameter "$ModemFlowControl" \
  2164.         "DTE-DCE flow control scheme"
  2165.     ModemFlowControl="$param";
  2166.     }
  2167.     test "$protoModemFlowControlCmd" && {
  2168.     promptForATCmdParameter "$ModemFlowControlCmd" \
  2169.         "Command for setting DCE-DTE flow control"
  2170.     ModemFlowControlCmd="$param";
  2171.     }
  2172.     test "$protoModemFrameFillOrder" && {
  2173.     promptForBitOrderParameter "$ModemFrameFillOrder" \
  2174.         "Bit order for HDLC frames"
  2175.     ModemFrameFillOrder="$param";
  2176.     }
  2177.     test "$protoModemHostFillOrder" && {
  2178.     promptForBitOrderParameter "$ModemHostFillOrder" \
  2179.         "Bit oder of host"
  2180.     ModemHostFillOrder="$param";
  2181.     }
  2182.     test "$protoModemInterPacketDelay" && {
  2183.     promptForNumericParameter "$ModemInterPacketDelay" \
  2184.         "Delay between modem writes (ms)"
  2185.     ModemInterPacketDelay="$param";
  2186.     }
  2187.     test "$protoModemMaxPacketSize" && {
  2188.     promptForNumericParameter "$ModemMaxPacketSize" \
  2189.         "Maximum data to write to the modem at once (bytes)"
  2190.     ModemMaxPacketSize="$param";
  2191.     }
  2192.     test "$protoModemMfrQueryCmd" && {
  2193.     promptForATCmdParameter "$ModemMfrQueryCmd" \
  2194.         "Command for querying modem manufacture"
  2195.     ModemMfrQueryCmd="$param";
  2196.     }
  2197.     test "$protoModemModelQueryCmd" && {
  2198.     promptForATCmdParameter "$ModemModelQueryCmd" \
  2199.         "Command for querying modem model"
  2200.     ModemModelQueryCmd="$param";
  2201.     }
  2202.     test "$protoModemNoAutoAnswerCmd" && {
  2203.     promptForATCmdParameter "$ModemNoAutoAnswerCmd" \
  2204.         "Command for disabling auto-answer"
  2205.     ModemNoAutoAnswerCmd="$param";
  2206.     }
  2207.     test "$protoModemOnHookCmd" && {
  2208.     promptForATCmdParameter "$ModemOnHookCmd" \
  2209.         "Command for placing phone \"on hook\" (hangup)"
  2210.     ModemOnHookCmd="$param";
  2211.     }
  2212.     test "$protoModemPageDoneTimeout" && {
  2213.     promptForNumericParameter "$ModemPageDoneTimeout" \
  2214.         "Page send/receive timeout (ms)"
  2215.     ModemPageDoneTimeout="$param";
  2216.     }
  2217.     test "$protoModemPageStartTimeout" && {
  2218.     promptForNumericParameter "$ModemPageStartTimeout" \
  2219.         "Page send/receive timeout (ms)"
  2220.     ModemPageStartTimeout="$param";
  2221.     }
  2222.     test "$protoModemRate" && {
  2223.     promptForNumericParameter "$ModemRate" \
  2224.         "DTE-DCE communication baud rate"
  2225.     ModemRate="$param";
  2226.     }
  2227.     test "$protoModemRecvFillOrder" && {
  2228.     promptForBitOrderParameter "$ModemRecvFillOrder" \
  2229.         "Bit order that modem sends received facsimile data"
  2230.     ModemRecvFillOrder="$param";
  2231.     }
  2232.     test "$protoModemResetCmds" && {
  2233.     promptForATCmdParameter "$ModemResetCmds" \
  2234.         "Additional commands for resetting the modem"
  2235.     ModemResetCmds="$param";
  2236.     }
  2237.     test "$protoModemResetDelay" && {
  2238.     promptForNumericParameter "$ModemResetDelay" \
  2239.         "Delay after sending modem reset commands (ms)"
  2240.     ModemResetDelay="$param";
  2241.     }
  2242.     test "$protoModemResultCodesCmd" && {
  2243.     promptForATCmdParameter "$ModemResultCodesCmd" \
  2244.         "Command for enabling result codes"
  2245.     ModemResultCodesCmd="$param";
  2246.     }
  2247.     test "$protoModemRevQueryCmd" && {
  2248.     promptForATCmdParameter "$ModemRevQueryCmd" \
  2249.         "Command for querying modem firmware revision"
  2250.     ModemRevQueryCmd="$param";
  2251.     }
  2252.     test "$protoModemSendFillOrder" && {
  2253.     promptForBitOrderParameter "$ModemSendFillOrder" \
  2254.         "Bit order that modem expects for transmitted facsimile data"
  2255.     ModemSendFillOrder="$param";
  2256.     }
  2257.     test "$protoModemSetVolumeCmd" && {
  2258.     promptForATCmdParameter "$ModemSetVolumeCmd" \
  2259.         "Commands for setting modem speaker volume levels"
  2260.     ModemSetVolumeCmd="$param";
  2261.     }
  2262.     test "$protoModemSetupAACmd" && {
  2263.     promptForATCmdParameter "$ModemSetupAACmd" \
  2264.         "Command for setting up adaptive-answer"
  2265.     ModemSetupAACmd="$param";
  2266.     }
  2267.     test "$protoModemSetupDCDCmd" && {
  2268.     promptForATCmdParameter "$ModemSetupDCDCmd" \
  2269.         "Command for setting up DCD handling"
  2270.     ModemSetupDCDCmd="$param";
  2271.     }
  2272.     test "$protoModemSetupDTRCmd" && {
  2273.     promptForATCmdParameter "$ModemSetupDTRCmd" \
  2274.         "Command for setting up DTR handling"
  2275.     ModemSetupDTRCmd="$param";
  2276.     }
  2277.     test "$protoModemSoftResetCmd" && {
  2278.     promptForATCmdParameter "$ModemSoftResetCmd" \
  2279.         "Command for doing a soft reset"
  2280.     ModemSoftResetCmd="$param";
  2281.     }
  2282.     test "$protoModemVerboseResultsCmd" && {
  2283.     promptForATCmdParameter "$ModemVerboseResultsCmd" \
  2284.         "Command for enabling verbose result codes"
  2285.     ModemVerboseResultsCmd="$param";
  2286.     }
  2287.     test "$protoModemWaitForConnect" && {
  2288.     promptForBooleanParameter "$ModemWaitForConnect" \
  2289.         "Force server to wait for \"CONNECT\" response on answer"
  2290.     ModemWaitForConnect="$param";
  2291.     }
  2292.     test "$protoModemWaitTimeCmd" && {
  2293.     promptForATCmdParameter "$ModemWaitTimeCmd" \
  2294.         "Command for setting time to wait for carrier when dialing"
  2295.     ModemWaitTimeCmd="$param";
  2296.     }
  2297.  
  2298.     test "$protoFaxT1Timer" && {
  2299.     promptForATCmdParameter "$FaxT1Timer" "CCITT T.30 T1 timer (ms)"
  2300.     FaxT1Timer="$param";
  2301.     }
  2302.     test "$protoFaxT2Timer" && {
  2303.     promptForATCmdParameter "$FaxT2Timer" "CCITT T.30 T2 timer (ms)"
  2304.     FaxT2Timer="$param";
  2305.     }
  2306.     test "$protoFaxT4Timer" && {
  2307.     promptForATCmdParameter "$FaxT4Timer" "CCITT T.30 T4 timer (ms)"
  2308.     FaxT4Timer="$param";
  2309.     }
  2310.     case "$ModemType" in
  2311.     Class1*)
  2312.     test "$protoClass1Cmd" && {
  2313.         promptForATCmdParameter "$Class1Cmd" "Command to enter Class 1"
  2314.         Class1Cmd="$param";
  2315.     }
  2316.     test "$protoClass1FrameOverhead" && {
  2317.         promptForNumericParameter "$Class1FrameOverhead" \
  2318.         "Extra bytes in a received HDLC frame"
  2319.         Class1FrameOverhead="$param";
  2320.     }
  2321.     test "$protoClass1RecvAbortOK" && {
  2322.         promptForNumericParameter "$Class1RecvAbortOK" \
  2323.         "Maximum time to wait for \"OK\" after aborting a receive (ms)"
  2324.         Class1RecvAbortOK="$param";
  2325.     }
  2326.     test "$protoClass1RecvIdentTimer" && {
  2327.         promptForNumericParameter "$Class1RecvIdentTimer" 
  2328.         "Maximum wait for initial identification frame (ms)"
  2329.         Class1RecvIdentTimer="$param";
  2330.     }
  2331.     test "$protoClass1SendPPMDelay" && {
  2332.         promptForNumericParameter "$Class1SendPPMDelay" \
  2333.         "Delay before sending post-page message (ms)"
  2334.         Class1SendPPMDelay="$param";
  2335.     }
  2336.     test "$protoClass1SendTCFDelay" && {
  2337.         promptForNumericParameter "$Class1SendTCFDelay"  \
  2338.         "Delay between sending TCF and ack/nak (ms)"
  2339.         Class1SendTCFDelay="$param";
  2340.     }
  2341.     test "$protoClass1TCFResponseDelay" && {
  2342.         promptForNumericParameter "$Class1TCFResponseDelay" \
  2343.         "Delay before sending DCS and TCF (ms)"
  2344.         Class1TCFResponseDelay="$param";
  2345.     }
  2346.     test "$protoClass1TrainingRecovery" && {
  2347.         promptForNumericParameter "$Class1TrainingRecovery" \
  2348.         "Delay after failed training (ms)"
  2349.         Class1TrainingRecovery="$param";
  2350.     }
  2351.     ;;
  2352.     Class2*)
  2353.     test "$protoClass2Cmd" && {
  2354.         promptForATCmdParameter "$Class2Cmd" \
  2355.         "Command to enter Class $ModemType"
  2356.         Class2Cmd="$param";
  2357.     }
  2358.     test "$protoClass2AbortCmd" && {
  2359.         promptForATCmdParameter "$Class2AbortCmd" \
  2360.             "Command to abort an active session"
  2361.         Class2AbortCmd="$param";
  2362.     }
  2363.     test "$protoClass2BORCmd" && {
  2364.         promptForATCmdParameter "$Class2BORCmd" \
  2365.         "Command to setup data bit order"
  2366.         Class2BORCmd="$param";
  2367.     }
  2368.     test "$protoClass2BUGCmd" && {
  2369.         promptForATCmdParameter "$Class2BUGCmd" \
  2370.         "Command to enable HDLC frame tracing"
  2371.         Class2BUGCmd="$param";
  2372.     }
  2373.     test "$protoClass2CIGCmd" && {
  2374.         promptForATCmdParameter "$Class2CIGCmd" \
  2375.         "Command to set polling identifer"
  2376.         Class2CIGCmd="$param";
  2377.     }
  2378.     test "$protoClass2CQCmd" && {
  2379.         promptForATCmdParameter "$Class2CQCmd" \
  2380.         "Command to setup copy quality parameters"
  2381.         Class2CQCmd="$param";
  2382.     }
  2383.     test "$protoClass2CRCmd" && {
  2384.         promptForATCmdParameter "$Class2CRCmd" \
  2385.         "Command to enable receive capability"
  2386.         Class2CRCmd="$param";
  2387.     }
  2388.     test "$protoClass2DCCCmd" && {
  2389.         promptForATCmdParameter "$Class2DCCCmd" \
  2390.         "Command to set/constrain modem capabilities"
  2391.         Class2DCCCmd="$param";
  2392.     }
  2393.     test "$protoClass2DCCQueryCmd" && {
  2394.         promptForATCmdParameter "$Class2DCCQueryCmd" \
  2395.         "Command to query modem capabilities"
  2396.         Class2DCCQueryCmd="$param";
  2397.     }
  2398.     test "$protoClass2DISCmd" && {
  2399.         promptForATCmdParameter "$Class2DISCmd" \
  2400.         "Command to set session parameters"
  2401.         Class2DISCmd="$param";
  2402.     }
  2403.     test "$protoClass2LIDCmd" && {
  2404.         promptForATCmdParameter "$Class2LIDCmd" \
  2405.         "Command to set local identifier string"
  2406.         Class2LIDCmd="$param";
  2407.     }
  2408.     test "$protoClass2NRCmd" && {
  2409.         promptForATCmdParameter "$Class2NRCmd" \
  2410.         "Command to enable status reporting"
  2411.         Class2NRCmd="$param";
  2412.     }
  2413.     test "$protoClass2PHCTOCmd" && {
  2414.         promptForATCmdParameter "$Class2PHCTOCmd" \
  2415.         "Command to set Phase C timeout"
  2416.         Class2PHCTOCmd="$param";
  2417.     }
  2418.     test "$protoClass2PIECmd" && {
  2419.         promptForATCmdParameter "$Class2PIECmd" \
  2420.         "Command to disable procedure interrupt handling"
  2421.         Class2PIECmd="$param";
  2422.     }
  2423.     test "$protoClass2RELCmd" && {
  2424.         promptForATCmdParameter "$Class2RELCmd" \
  2425.         "Command to enable delivery of byte-aligned EOL codes"
  2426.         Class2RELCmd="$param";
  2427.     }
  2428.     test "$protoClass2RecvDataTrigger" && {
  2429.         promptForATCmdParameter "$Class2RecvDataTrigger" \
  2430.         "Character sent before receiving page data";
  2431.         Class2RecvDataTrigger="$param";
  2432.     }
  2433.     test "$protoClass2SPLCmd" && {
  2434.         promptForATCmdParameter "$Class2SPLCmd" \
  2435.         "Command to set polling request"
  2436.         Class2SPLCmd="$param";
  2437.     }
  2438.     test "$protoClass2TBCCmd" && {
  2439.         promptForATCmdParameter "$Class2TBCCmd" \
  2440.         "Command to enable DTE-DCE stream communication mode"
  2441.         Class2TBCCmd="$param";
  2442.     }
  2443.     test "$protoClass2XmitWaitForXON" && {
  2444.         promptForBooleanParameter "$Class2XmitWaitForXON" \
  2445.         "Wait for XON before sending page data"
  2446.         Class2XmitWaitForXON="$param";
  2447.     }
  2448.     ;;
  2449.     esac
  2450. }
  2451.  
  2452. #
  2453. # Construct the configuration file.
  2454. #
  2455. if [ $ProtoType = config.skel    \
  2456.   -o $ProtoType = config.class1    \
  2457.   -o $ProtoType = config.class2    \
  2458. ]; then
  2459.     # Go through each important parameter (sigh)
  2460. cat<<EOF
  2461.  
  2462. There is no prototype configuration file for your modem, so we will
  2463. have to fill in the appropriate parameters by hand.  You will need the
  2464. manual for how to program your modem to do this task.  In case you are
  2465. uncertain of the meaning of a configuration parameter you should
  2466. consult the config(4F) manual page for an explanation.
  2467.  
  2468. Note that modem commands are specified without a leading "AT".  The "AT"
  2469. will not be displayed in the prompts and if you include a leading "AT"
  2470. it will automatically be deleted.  Likewise quote marks (") will not be
  2471. displayed and will automatically be deleted.  You can use this facility
  2472. to supply null parameters as "".
  2473.  
  2474. Finally, beware that the set of parameters is long.  If you prefer to
  2475. use your favorite editor instead of this script you should fill things
  2476. in here as best you can and then edit the configuration file
  2477.  
  2478. "$CONFIG"
  2479.  
  2480. after completing this procedure.
  2481.  
  2482. EOF
  2483.     ok="no"
  2484. else
  2485.     ok="skip"
  2486. fi
  2487.  
  2488. getModemProtoParameters $proto
  2489. while [ "$ok" != "" -a "$ok" != "y" -a "$ok" != "yes" ]; do
  2490.     if [ "$ok" != "skip" ]; then
  2491.     promptForModemParameters
  2492.     fi
  2493.     printModemConfig
  2494.     if [ "$OS" = "IRIX" ]; then
  2495.     checkFlowControlAgainstTTY
  2496.     fi
  2497.     #
  2498.     # XXX not sure what kind of consistency checking that can
  2499.     # done w/o knowing more about the modem...
  2500.     #
  2501.     prompt "Are these ok [yes]?"; read ok
  2502. done
  2503. makeSedModemCommands
  2504.  
  2505. #
  2506. # Re-read the server-related prototype parameters from
  2507. # the prototype file that we know we're going to hand to
  2508. # sed and construct the sed substitute commands that
  2509. # transform things according to the typed-in values.
  2510. #
  2511. getServerProtoParameters $proto
  2512. #
  2513. # If getty use was previously enabled, try to sed any
  2514. # existing GettyArgs line in the prototype file.  Otherwise
  2515. # try to uncomment the GettyArgs line in the prototype
  2516. # file--though this is not likely to do the right thing (sigh).
  2517. #
  2518. if [ "$protoGettyArgs" ]; then
  2519.     addServerSedCmd "$protoGettyArgs" "$GettyArgs" GettyArgs
  2520. else
  2521.     ServerCmds="$ServerCmds -e '/GettyArgs:/s/^#//'"
  2522. fi
  2523. makeSedServerCommands
  2524.  
  2525. #
  2526. # All done with the prompting; edit up a config file!
  2527. #
  2528. if [ -f $CONFIG ]; then
  2529.     echo "Saving existing configuration file as \"$CONFIG.sav\"."
  2530.     mv $CONFIG $CONFIG.sav
  2531. fi
  2532. echo "Creating new configuration file \"$CONFIG\"."
  2533. eval sed "$ServerCmds" "$ModemCmds" '-e /CONFIG:/d' $proto >$CONFIG
  2534. chown $FAX $CONFIG; chgrp $faxGID $CONFIG; chmod 644 $CONFIG
  2535.  
  2536. #
  2537. # Create FIFO.<tty> special file.
  2538. #
  2539. FIFO=$SPOOL/FIFO.$DEVID
  2540. echo "Creating \"$FIFO\" in the spooling directory."
  2541. test -p $FIFO \
  2542.     || (mkfifo $FIFO) >/dev/null 2>&1 \
  2543.     || (mknod $FIFO p) >/dev/null 2>&1 \
  2544.     || { echo "Cannot create fifo \"$FIFO\""; exit 1; }
  2545. chown $FAX $FIFO; chgrp $faxGID $FIFO; chmod 600 $FIFO
  2546.  
  2547. echo "Done setting up the modem configuration."
  2548.  
  2549. #
  2550. # And, last but not least, startup a server for the modem.
  2551. #
  2552. echo ""
  2553. prompt "Startup a facsimile server for this modem [yes]?"; read x
  2554. if [ "$x" = "" -o "$x" = "yes" -o "$x" = "y" ]; then
  2555.     echo "$SERVERDIR/faxd -m /dev/$TTY&"
  2556.     $SERVERDIR/faxd -m /dev/$TTY&
  2557. fi
  2558. exec >/dev/null 2>&1
  2559.